More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 100,535 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Emergency Withdr... | 58665839 | 585 days ago | IN | 0 FTM | 0.00155396 | ||||
Withdraw | 50840570 | 720 days ago | IN | 0 FTM | 0.0307116 | ||||
Emergency Withdr... | 48848599 | 755 days ago | IN | 0 FTM | 0.00010251 | ||||
Emergency Withdr... | 48848410 | 755 days ago | IN | 0 FTM | 0.00010251 | ||||
Emergency Withdr... | 48847262 | 755 days ago | IN | 0 FTM | 0.00007306 | ||||
Emergency Withdr... | 48847216 | 755 days ago | IN | 0 FTM | 0.00082189 | ||||
Emergency Withdr... | 48847119 | 755 days ago | IN | 0 FTM | 0.00021092 | ||||
Emergency Withdr... | 48847057 | 755 days ago | IN | 0 FTM | 0.0000546 | ||||
Emergency Withdr... | 48846916 | 755 days ago | IN | 0 FTM | 0.00013252 | ||||
Emergency Withdr... | 48846882 | 755 days ago | IN | 0 FTM | 0.00006723 | ||||
Emergency Withdr... | 48846824 | 755 days ago | IN | 0 FTM | 0.00005353 | ||||
Emergency Withdr... | 48846738 | 755 days ago | IN | 0 FTM | 0.00005365 | ||||
Emergency Withdr... | 48846647 | 755 days ago | IN | 0 FTM | 0.00005388 | ||||
Emergency Withdr... | 48846613 | 755 days ago | IN | 0 FTM | 0.00090905 | ||||
Emergency Withdr... | 48846592 | 755 days ago | IN | 0 FTM | 0.00007496 | ||||
Emergency Withdr... | 48846317 | 755 days ago | IN | 0 FTM | 0.0000554 | ||||
Emergency Withdr... | 48846110 | 755 days ago | IN | 0 FTM | 0.00009693 | ||||
Emergency Withdr... | 48845913 | 755 days ago | IN | 0 FTM | 0.00005913 | ||||
Emergency Withdr... | 48845363 | 755 days ago | IN | 0 FTM | 0.00021418 | ||||
Emergency Withdr... | 48843335 | 755 days ago | IN | 0 FTM | 0.000053 | ||||
Emergency Withdr... | 48842954 | 755 days ago | IN | 0 FTM | 0.00005888 | ||||
Emergency Withdr... | 48840995 | 755 days ago | IN | 0 FTM | 0.00007247 | ||||
Withdraw | 40310661 | 876 days ago | IN | 0 FTM | 0.00410497 | ||||
Deposit | 31579925 | 986 days ago | IN | 0 FTM | 0.01202236 | ||||
Emergency Withdr... | 29685860 | 1006 days ago | IN | 0 FTM | 0.00696477 |
Loading...
Loading
Contract Name:
MasterChef
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2021-10-12 */ /** *Submitted for verification at FtmScan.com on 2021-09-06 */ // SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the bep token owner. */ function getOwner() external view returns (address); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address _owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } contract BEP20 is Context, IBEP20, Ownable { using SafeMath for uint256; using Address for address; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor(string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } /** * @dev Returns the bep token owner. */ function getOwner() external override view returns (address) { return owner(); } /** * @dev Returns the token name. */ function name() public override view returns (string memory) { return _name; } /** * @dev Returns the token decimals. */ function decimals() public override view returns (uint8) { return _decimals; } /** * @dev Returns the token symbol. */ function symbol() public override view returns (string memory) { return _symbol; } /** * @dev See {BEP20-totalSupply}. */ function totalSupply() public override view returns (uint256) { return _totalSupply; } /** * @dev See {BEP20-balanceOf}. */ function balanceOf(address account) public override view returns (uint256) { return _balances[account]; } /** * @dev See {BEP20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {BEP20-allowance}. */ function allowance(address owner, address spender) public override view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {BEP20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {BEP20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {BEP20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for `sender`'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public override returns (bool) { _transfer(sender, recipient, amount); _approve( sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance") ); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {BEP20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {BEP20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero") ); return true; } /** * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing * the total supply. * * Requirements * * - `msg.sender` must be the token owner */ function mint(uint256 amount) public onlyOwner returns (bool) { _mint(_msgSender(), amount); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal { require(account != address(0), "BEP20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal { require(account != address(0), "BEP20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal { require(owner != address(0), "BEP20: approve from the zero address"); require(spender != address(0), "BEP20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Destroys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve( account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance") ); } } // ScareCrow with Governance. contract ScareCrow is BEP20('ScareCrow', 'SCARE') { /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef). function mint(address _to, uint256 _amount) public onlyOwner { _mint(_to, _amount); _moveDelegates(address(0), _delegates[_to], _amount); } // Copied and modified from YAM code: // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol // Which is copied and modified from COMPOUND: // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol /// @notice A record of each accounts delegate mapping (address => address) internal _delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint256 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegator The address to get delegatee for */ function delegates(address delegator) external view returns (address) { return _delegates[delegator]; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) external { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig( address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s ) external { bytes32 domainSeparator = keccak256( abi.encode( DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this) ) ); bytes32 structHash = keccak256( abi.encode( DELEGATION_TYPEHASH, delegatee, nonce, expiry ) ); bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", domainSeparator, structHash ) ); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "SCARE::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "SCARE::delegateBySig: invalid nonce"); require(now <= expiry, "SCARE::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint256) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) external view returns (uint256) { require(blockNumber < block.number, "SCARE::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = _delegates[delegator]; uint256 delegatorBalance = balanceOf(delegator); // balance of underlying VICTs (not scaled); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { // decrease old representative uint32 srcRepNum = numCheckpoints[srcRep]; uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint256 srcRepNew = srcRepOld.sub(amount); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { // increase new representative uint32 dstRepNum = numCheckpoints[dstRep]; uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint256 dstRepNew = dstRepOld.add(amount); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32(block.number, "SCARE::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } /** * @title SafeBEP20 * @dev Wrappers around BEP20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer( IBEP20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IBEP20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IBEP20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IBEP20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IBEP20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IBEP20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).sub( value, "SafeBEP20: decreased allowance below zero" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IBEP20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } // MasterChef is the master of SCARE. He can make Scare and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SCARE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless. contract MasterChef is Ownable, ReentrancyGuard { using SafeMath for uint256; using SafeBEP20 for IBEP20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SCARE // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accScarePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accScarePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IBEP20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SCARE to distribute per block. uint256 lastRewardBlock; // Last block that SCARE distribution occurs. uint256 accScarePerShare; // Accumulated SCARE per share, times 1e12. See below. uint16 depositFeeBP; // Deposit fee in basis points uint256 lpSupply; } // The SCARE TOKEN! ScareCrow public scare; // Dev address. address public devaddr; // SCARE tokens created per block. uint256 public scarePerBlock; // Bonus muliplier for early SCARE makers. uint256 public constant BONUS_MULTIPLIER = 1; // Deposit Fee address address public feeAddress1; address public feeAddress2; address public feeAddress3; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Total allocation points. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when Scare mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); event SetFeeAddress1(address indexed user, address indexed newAddress); event SetFeeAddress2(address indexed user, address indexed newAddress); event SetFeeAddress3(address indexed user, address indexed newAddress); event SetDevAddress(address indexed user, address indexed newAddress); event UpdateEmissionRate(address indexed user, uint256 scarePerBlock); event addPool(uint256 indexed pid, address lpToken, uint256 allocPoint, uint256 depositFeeBP); event setPool(uint256 indexed pid, address lpToken, uint256 allocPoint, uint256 depositFeeBP); event UpdateStartBlock(uint256 newStartBlock); constructor( ScareCrow _scare, address _devaddr, address _feeAddress1, address _feeAddress2, address _feeAddress3, uint256 _scarePerBlock, uint256 _startBlock ) public { scare = _scare; devaddr = _devaddr; feeAddress1 = _feeAddress1; feeAddress2 = _feeAddress2; feeAddress3 = _feeAddress3; scarePerBlock = _scarePerBlock; startBlock = _startBlock; } function poolLength() external view returns (uint256) { return poolInfo.length; } mapping(IBEP20 => bool) public poolExistence; modifier nonDuplicated(IBEP20 _lpToken) { require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated"); _; } // Add a new lp to the pool. Can only be called by the owner. function add(uint256 _allocPoint, IBEP20 _lpToken, uint16 _depositFeeBP, bool _withUpdate) external onlyOwner nonDuplicated(_lpToken) { // valid ERC20 token _lpToken.balanceOf(address(this)); require(_depositFeeBP <= 400, "add: invalid deposit fee basis points"); if (_withUpdate) { massUpdatePools(); } uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolExistence[_lpToken] = true; poolInfo.push(PoolInfo({ lpToken : _lpToken, allocPoint : _allocPoint, lastRewardBlock: lastRewardBlock, accScarePerShare : 0, depositFeeBP : _depositFeeBP, lpSupply: 0 })); emit addPool(poolInfo.length - 1, address(_lpToken), _allocPoint, _depositFeeBP); } // Update the given pool's SCARE allocation point and deposit fee. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, bool _withUpdate) external onlyOwner { require(_depositFeeBP <= 400, "set: invalid deposit fee basis points"); if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; poolInfo[_pid].depositFeeBP = _depositFeeBP; emit setPool(_pid, address(poolInfo[_pid].lpToken), _allocPoint, _depositFeeBP); } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) { return _to.sub(_from); } // View function to see pending SCARE on frontend. function pendingScare(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accScarePerShare = pool.accScarePerShare; if (block.number > pool.lastRewardBlock && pool.lpSupply != 0 && totalAllocPoint > 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 scareReward = multiplier.mul(scarePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accScarePerShare = accScarePerShare.add(scareReward.mul(1e12).div(pool.lpSupply)); } return user.amount.mul(accScarePerShare).div(1e12).sub(user.rewardDebt); } // Update reward variables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } if (pool.lpSupply == 0 || pool.allocPoint == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 scareReward = multiplier.mul(scarePerBlock).mul(pool.allocPoint).div(totalAllocPoint); scare.mint(devaddr, scareReward.div(10)); scare.mint(address(this), scareReward); pool.accScarePerShare = pool.accScarePerShare.add(scareReward.mul(1e12).div(pool.lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to MasterChef for SCARE allocation. function deposit(uint256 _pid, uint256 _amount) external nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accScarePerShare).div(1e12).sub(user.rewardDebt); if (pending > 0) { safeScareTransfer(msg.sender, pending); } } if (_amount > 0) { uint256 previousAmount = pool.lpToken.balanceOf(address(this)); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); uint256 afterAmount = pool.lpToken.balanceOf(address(this)); _amount = afterAmount.sub(previousAmount); if (pool.depositFeeBP > 0) { uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000); pool.lpToken.safeTransfer(feeAddress1, depositFee.div(3)); pool.lpToken.safeTransfer(feeAddress2, depositFee.div(3)); pool.lpToken.safeTransfer(feeAddress3, depositFee.div(3)); user.amount = user.amount.add(_amount).sub(depositFee); pool.lpSupply = pool.lpSupply.add(_amount).sub(depositFee); } else { user.amount = user.amount.add(_amount); pool.lpSupply = pool.lpSupply.add(_amount); } } user.rewardDebt = user.amount.mul(pool.accScarePerShare).div(1e12); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from MasterChef. function withdraw(uint256 _pid, uint256 _amount) external nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accScarePerShare).div(1e12).sub(user.rewardDebt); if (pending > 0) { safeScareTransfer(msg.sender, pending); } if (_amount > 0) { user.amount = user.amount.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); pool.lpSupply = pool.lpSupply.sub(_amount); } user.rewardDebt = user.amount.mul(pool.accScarePerShare).div(1e12); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) external nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint256 amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), amount); if (pool.lpSupply >= amount) { pool.lpSupply = pool.lpSupply.sub(amount); } else { pool.lpSupply = 0; } emit EmergencyWithdraw(msg.sender, _pid, amount); } // Safe scare transfer function, just in case if rounding error causes pool to not have enough SCARE. function safeScareTransfer(address _to, uint256 _amount) internal { uint256 scareBal = scare.balanceOf(address(this)); bool transferSuccess = false; if (_amount > scareBal) { transferSuccess = scare.transfer(_to, scareBal); } else { transferSuccess = scare.transfer(_to, _amount); } require(transferSuccess, "safeScareTransfer: transfer failed"); } // Update dev address. function setDevAddress(address _devaddr) external { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; emit SetDevAddress(msg.sender, _devaddr); } function setFeeAddress1(address _feeAddress1) external { require(msg.sender == feeAddress1, "setFeeAddress1: FORBIDDEN"); require(_feeAddress1 != address(0), "!nonzero"); feeAddress1 = _feeAddress1; emit SetFeeAddress1(msg.sender, _feeAddress1); } function setFeeAddress2(address _feeAddress2) external { require(msg.sender == feeAddress2, "setFeeAddress2: FORBIDDEN"); require(_feeAddress2 != address(0), "!nonzero"); feeAddress2 = _feeAddress2; emit SetFeeAddress2(msg.sender, _feeAddress2); } function setFeeAddress3(address _feeAddress3) external { require(msg.sender == feeAddress3, "setFeeAddress3: FORBIDDEN"); require(_feeAddress3 != address(0), "!nonzero"); feeAddress3 = _feeAddress3; emit SetFeeAddress3(msg.sender, _feeAddress3); } //Pancake has to add hidden dummy pools inorder to alter the emission, here we make it simple and transparent to all. function updateEmissionRate(uint256 _scarePerBlock) external onlyOwner { massUpdatePools(); scarePerBlock = _scarePerBlock; emit UpdateEmissionRate(msg.sender, _scarePerBlock); } // Only update before start of farm function updateStartBlock(uint256 _newStartBlock) external onlyOwner { require(block.number < startBlock, "cannot change start block if farm has already started"); require(block.number < _newStartBlock, "cannot set start block in the past"); uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { PoolInfo storage pool = poolInfo[pid]; pool.lastRewardBlock = _newStartBlock; } startBlock = _newStartBlock; emit UpdateStartBlock(startBlock); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract ScareCrow","name":"_scare","type":"address"},{"internalType":"address","name":"_devaddr","type":"address"},{"internalType":"address","name":"_feeAddress1","type":"address"},{"internalType":"address","name":"_feeAddress2","type":"address"},{"internalType":"address","name":"_feeAddress3","type":"address"},{"internalType":"uint256","name":"_scarePerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress2","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress3","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"scarePerBlock","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newStartBlock","type":"uint256"}],"name":"UpdateStartBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositFeeBP","type":"uint256"}],"name":"addPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositFeeBP","type":"uint256"}],"name":"setPool","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IBEP20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devaddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingScare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IBEP20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IBEP20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accScarePerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"lpSupply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"scare","outputs":[{"internalType":"contract ScareCrow","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"scarePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress1","type":"address"}],"name":"setFeeAddress1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress2","type":"address"}],"name":"setFeeAddress2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress3","type":"address"}],"name":"setFeeAddress3","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_scarePerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newStartBlock","type":"uint256"}],"name":"updateStartBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000046e1ee17f51c52661d04238f1700c547de3b84a100000000000000000000000067aa010b59b61d057ba4899154184b6afa7029cf00000000000000000000000000b8a788acc8c8d2d74f3f343316c31a16007924000000000000000000000000635d4309cfac7097a3351e523e81ad7b3b79cd66000000000000000000000000d32676c0c264232a995587bd664fe7a585c914f1000000000000000000000000000000000000000000000000016345785d8a00000000000000000000000000000000000000000000000000000000000001298be0
-----Decoded View---------------
Arg [0] : _scare (address): 0x46e1Ee17f51c52661D04238F1700C547dE3B84A1
Arg [1] : _devaddr (address): 0x67AA010B59b61D057ba4899154184b6aFA7029CF
Arg [2] : _feeAddress1 (address): 0x00B8A788acC8c8D2d74f3F343316c31a16007924
Arg [3] : _feeAddress2 (address): 0x635d4309CFac7097a3351e523e81AD7B3B79CD66
Arg [4] : _feeAddress3 (address): 0xD32676c0c264232A995587bd664FE7A585C914F1
Arg [5] : _scarePerBlock (uint256): 100000000000000000
Arg [6] : _startBlock (uint256): 19500000
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 00000000000000000000000046e1ee17f51c52661d04238f1700c547de3b84a1
Arg [1] : 00000000000000000000000067aa010b59b61d057ba4899154184b6afa7029cf
Arg [2] : 00000000000000000000000000b8a788acc8c8d2d74f3f343316c31a16007924
Arg [3] : 000000000000000000000000635d4309cfac7097a3351e523e81ad7b3b79cd66
Arg [4] : 000000000000000000000000d32676c0c264232a995587bd664fe7a585c914f1
Arg [5] : 000000000000000000000000000000000000000000000000016345785d8a0000
Arg [6] : 0000000000000000000000000000000000000000000000000000000001298be0
Deployed Bytecode Sourcemap
46442:13490:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50099:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59108:210;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48351:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48592:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48223:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;55863:817;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52324:736;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48684:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47942:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;53399:759;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;56751:562;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;53143:180;;;:::i;:::-;;12674:148;;;:::i;:::-;;48061:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50469:926;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58689:288;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48144:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12023:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;52139:121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58097:288;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48433:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;50202:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;57897:192;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47992:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;51508:555;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48289:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;54228:1583;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58393:288;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48256:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;12977:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59367:562;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50099:95;50144:7;50171:8;:15;;;;50164:22;;50099:95;:::o;59108:210::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59190:17:::1;:15;:17::i;:::-;59234:14;59218:13;:30;;;;59283:10;59264:46;;;59295:14;59264:46;;;;;;;;;;;;;;;;;;59108:210:::0;:::o;48351:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;48592:34::-;;;;:::o;48223:26::-;;;;;;;;;;;;;:::o;55863:817::-;1783:1;2389:7;;:19;;2381:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1783:1;2522:7;:18;;;;55945:21:::1;55969:8;55978:4;55969:14;;;;;;;;;;;;;;;;;;55945:38;;55994:21;56018:8;:14;56027:4;56018:14;;;;;;;;;;;:26;56033:10;56018:26;;;;;;;;;;;;;;;55994:50;;56078:7;56063:4;:11;;;:22;;56055:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;56119:16;56130:4;56119:10;:16::i;:::-;56146:15;56164:69;56217:4;:15;;;56164:48;56207:4;56164:38;56180:4;:21;;;56164:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;:52;;:69;;;;:::i;:::-;56146:87;;56258:1;56248:7;:11;56244:82;;;56276:38;56294:10;56306:7;56276:17;:38::i;:::-;56244:82;56350:1;56340:7;:11;56336:209;;;56382:24;56398:7;56382:4;:11;;;:15;;:24;;;;:::i;:::-;56368:4;:11;;:38;;;;56421:55;56455:10;56468:7;56421:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;56507:26;56525:7;56507:4;:13;;;:17;;:26;;;;:::i;:::-;56491:4;:13;;:42;;;;56336:209;56573:48;56616:4;56573:38;56589:4;:21;;;56573:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;56555:4;:15;;:66;;;;56658:4;56646:10;56637:35;;;56664:7;56637:35;;;;;;;;;;;;;;;;;;2553:1;;;1739::::0;2701:7;:22;;;;55863:817;;:::o;52324:736::-;52398:7;52418:21;52442:8;52451:4;52442:14;;;;;;;;;;;;;;;;;;52418:38;;52467:21;52491:8;:14;52500:4;52491:14;;;;;;;;;;;:21;52506:5;52491:21;;;;;;;;;;;;;;;52467:45;;52523:24;52550:4;:21;;;52523:48;;52602:4;:20;;;52586:12;:36;:59;;;;;52644:1;52627:4;:13;;;:18;;52586:59;:82;;;;;52667:1;52649:15;;:19;52586:82;52582:389;;;52685:18;52706:49;52720:4;:20;;;52742:12;52706:13;:49::i;:::-;52685:70;;52770:19;52792:71;52847:15;;52792:50;52826:4;:15;;;52792:29;52807:13;;52792:10;:14;;:29;;;;:::i;:::-;:33;;:50;;;;:::i;:::-;:54;;:71;;;;:::i;:::-;52770:93;;52897:62;52918:40;52944:4;:13;;;52918:21;52934:4;52918:11;:15;;:21;;;;:::i;:::-;:25;;:40;;;;:::i;:::-;52897:16;:20;;:62;;;;:::i;:::-;52878:81;;52582:389;;;52988:64;53036:4;:15;;;52988:43;53026:4;52988:33;53004:16;52988:4;:11;;;:15;;:33;;;;:::i;:::-;:37;;:43;;;;:::i;:::-;:47;;:64;;;;:::i;:::-;52981:71;;;;;52324:736;;;;:::o;48684:25::-;;;;:::o;47942:22::-;;;;;;;;;;;;;:::o;53399:759::-;53451:21;53475:8;53484:4;53475:14;;;;;;;;;;;;;;;;;;53451:38;;53521:4;:20;;;53504:12;:37;53500:76;;53558:7;;;53500:76;53607:1;53590:4;:13;;;:18;:42;;;;53631:1;53612:4;:15;;;:20;53590:42;53586:132;;;53673:12;53649:4;:20;;:36;;;;53700:7;;;53586:132;53728:18;53749:49;53763:4;:20;;;53785:12;53749:13;:49::i;:::-;53728:70;;53809:19;53831:71;53886:15;;53831:50;53865:4;:15;;;53831:29;53846:13;;53831:10;:14;;:29;;;;:::i;:::-;:33;;:50;;;;:::i;:::-;:54;;:71;;;;:::i;:::-;53809:93;;53913:5;;;;;;;;;;;:10;;;53924:7;;;;;;;;;;;53933:19;53949:2;53933:11;:15;;:19;;;;:::i;:::-;53913:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53964:5;;;;;;;;;;;:10;;;53983:4;53990:11;53964:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54037:67;54063:40;54089:4;:13;;;54063:21;54079:4;54063:11;:15;;:21;;;;:::i;:::-;:25;;:40;;;;:::i;:::-;54037:4;:21;;;:25;;:67;;;;:::i;:::-;54013:4;:21;;:91;;;;54138:12;54115:4;:20;;:35;;;;53399:759;;;;;:::o;56751:562::-;1783:1;2389:7;;:19;;2381:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1783:1;2522:7;:18;;;;56825:21:::1;56849:8;56858:4;56849:14;;;;;;;;;;;;;;;;;;56825:38;;56874:21;56898:8;:14;56907:4;56898:14;;;;;;;;;;;:26;56913:10;56898:26;;;;;;;;;;;;;;;56874:50;;56935:14;56952:4;:11;;;56935:28;;56988:1;56974:4;:11;;:15;;;;57018:1;57000:4;:15;;:19;;;;57030:54;57064:10;57077:6;57030:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;57119:6;57101:4;:13;;;:24;57097:148;;57158:25;57176:6;57158:4;:13;;;:17;;:25;;;;:::i;:::-;57142:4;:13;;:41;;;;57097:148;;;57232:1;57216:4;:13;;:17;;;;57097:148;57292:4;57280:10;57262:43;;;57298:6;57262:43;;;;;;;;;;;;;;;;;;2553:1;;;1739::::0;2701:7;:22;;;;56751:562;:::o;53143:180::-;53188:14;53205:8;:15;;;;53188:32;;53236:11;53231:85;53259:6;53253:3;:12;53231:85;;;53289:15;53300:3;53289:10;:15::i;:::-;53267:5;;;;;53231:85;;;;53143:180;:::o;12674:148::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12781:1:::1;12744:40;;12765:6;::::0;::::1;;;;;;;;12744:40;;;;;;;;;;;;12812:1;12795:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;12674:148::o:0;48061:28::-;;;;:::o;50469:926::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50593:8:::1;50339:5;50312:32;;:13;:23;50326:8;50312:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;50304:70;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;50644:8:::2;:18;;;50671:4;50644:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;50715:3;50698:13;:20;;;;50690:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50775:11;50771:61;;;50803:17;:15;:17::i;:::-;50771:61;50842:23;50884:10;;50869:12;:25;:53;;50912:10;;50869:53;;;50897:12;50869:53;50842:80;;50951:32;50971:11;50951:15;;:19;;:32;;;;:::i;:::-;50933:15;:50;;;;51020:4;50994:13;:23;51008:8;50994:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;51035:8;51049:244;;;;;;;;51083:8;51049:244;;;;;;51119:11;51049:244;;;;51162:15;51049:244;;;;51211:1;51049:244;;;;51242:13;51049:244;;;;;;51280:1;51049:244;;::::0;51035:259:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51338:1;51320:8;:15;;;;:19;51312:75;51349:8;51360:11;51373:13;51312:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50385:1;12314::::1;50469:926:::0;;;;:::o;58689:288::-;58777:11;;;;;;;;;;;58763:25;;:10;:25;;;58755:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58861:1;58837:26;;:12;:26;;;;58829:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58901:12;58887:11;;:26;;;;;;;;;;;;;;;;;;58956:12;58929:40;;58944:10;58929:40;;;;;;;;;;;;58689:288;:::o;48144:44::-;48187:1;48144:44;:::o;12023:87::-;12069:7;12096:6;;;;;;;;;;;12089:13;;12023:87;:::o;52139:121::-;52211:7;52238:14;52246:5;52238:3;:7;;:14;;;;:::i;:::-;52231:21;;52139:121;;;;:::o;58097:288::-;58185:11;;;;;;;;;;;58171:25;;:10;:25;;;58163:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58269:1;58245:26;;:12;:26;;;;58237:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58309:12;58295:11;;:26;;;;;;;;;;;;;;;;;;58364:12;58337:40;;58352:10;58337:40;;;;;;;;;;;;58097:288;:::o;48433:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50202:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;57897:192::-;57980:7;;;;;;;;;;;57966:21;;:10;:21;;;57958:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58022:8;58012:7;;:18;;;;;;;;;;;;;;;;;;58072:8;58046:35;;58060:10;58046:35;;;;;;;;;;;;57897:192;:::o;47992:22::-;;;;;;;;;;;;;:::o;51508:555::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51651:3:::1;51634:13;:20;;;;51626:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51711:11;51707:61;;;51739:17;:15;:17::i;:::-;51707:61;51796:63;51847:11;51796:46;51816:8;51825:4;51816:14;;;;;;;;;;;;;;;;;;:25;;;51796:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;51778:15;:81;;;;51898:11;51870:8;51879:4;51870:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;51950:13;51920:8;51929:4;51920:14;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;51989:4;51981:74;52003:8;52012:4;52003:14;;;;;;;;;;;;;;;;;;:22;;;;;;;;;;;;52028:11;52041:13;51981:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51508:555:::0;;;;:::o;48289:26::-;;;;;;;;;;;;;:::o;54228:1583::-;1783:1;2389:7;;:19;;2381:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1783:1;2522:7;:18;;;;54309:21:::1;54333:8;54342:4;54333:14;;;;;;;;;;;;;;;;;;54309:38;;54358:21;54382:8;:14;54391:4;54382:14;;;;;;;;;;;:26;54397:10;54382:26;;;;;;;;;;;;;;;54358:50;;54419:16;54430:4;54419:10;:16::i;:::-;54464:1;54450:4;:11;;;:15;54446:239;;;54482:15;54500:69;54553:4;:15;;;54500:48;54543:4;54500:38;54516:4;:21;;;54500:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;:52;;:69;;;;:::i;:::-;54482:87;;54598:1;54588:7;:11;54584:90;;;54620:38;54638:10;54650:7;54620:17;:38::i;:::-;54584:90;54446:239;;54709:1;54699:7;:11;54695:982;;;54727:22;54752:4;:12;;;;;;;;;;;;:22;;;54783:4;54752:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;54727:62;;54804:74;54842:10;54863:4;54870:7;54804:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;54893:19;54916:4;:12;;;;;;;;;;;;:22;;;54947:4;54916:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;54893:60;;54978:31;54994:14;54978:11;:15;;:31;;;;:::i;:::-;54968:41;;55048:1;55028:4;:17;;;;;;;;;;;;:21;;;55024:642;;;55070:18;55091:41;55126:5;55091:30;55103:4;:17;;;;;;;;;;;;55091:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;55070:62;;55151:57;55177:11;;;;;;;;;;;55190:17;55205:1;55190:10;:14;;:17;;;;:::i;:::-;55151:4;:12;;;;;;;;;;;;:25;;;;:57;;;;;:::i;:::-;55227;55253:11;;;;;;;;;;;55266:17;55281:1;55266:10;:14;;:17;;;;:::i;:::-;55227:4;:12;;;;;;;;;;;;:25;;;;:57;;;;;:::i;:::-;55303;55329:11;;;;;;;;;;;55342:17;55357:1;55342:10;:14;;:17;;;;:::i;:::-;55303:4;:12;;;;;;;;;;;;:25;;;;:57;;;;;:::i;:::-;55393:40;55422:10;55393:24;55409:7;55393:4;:11;;;:15;;:24;;;;:::i;:::-;:28;;:40;;;;:::i;:::-;55379:4;:11;;:54;;;;55468:42;55499:10;55468:26;55486:7;55468:4;:13;;;:17;;:26;;;;:::i;:::-;:30;;:42;;;;:::i;:::-;55452:4;:13;;:58;;;;55024:642;;;;55565:24;55581:7;55565:4;:11;;;:15;;:24;;;;:::i;:::-;55551:4;:11;;:38;;;;55624:26;55642:7;55624:4;:13;;;:17;;:26;;;;:::i;:::-;55608:4;:13;;:42;;;;55024:642;54695:982;;;55705:48;55748:4;55705:38;55721:4;:21;;;55705:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48;;;;:::i;:::-;55687:4;:15;;:66;;;;55789:4;55777:10;55769:34;;;55795:7;55769:34;;;;;;;;;;;;;;;;;;2553:1;;1739::::0;2701:7;:22;;;;54228:1583;;:::o;58393:288::-;58481:11;;;;;;;;;;;58467:25;;:10;:25;;;58459:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58565:1;58541:26;;:12;:26;;;;58533:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58605:12;58591:11;;:26;;;;;;;;;;;;;;;;;;58660:12;58633:40;;58648:10;58633:40;;;;;;;;;;;;58393:288;:::o;48256:26::-;;;;;;;;;;;;;:::o;12977:244::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13086:1:::1;13066:22;;:8;:22;;;;13058:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13176:8;13147:38;;13168:6;::::0;::::1;;;;;;;;13147:38;;;;;;;;;;;;13205:8;13196:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;12977:244:::0;:::o;59367:562::-;12254:12;:10;:12::i;:::-;12243:23;;:7;:5;:7::i;:::-;:23;;;12235:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59470:10:::1;;59455:12;:25;59447:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59572:14;59557:12;:29;59549:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59636:14;59653:8;:15;;;;59636:32;;59684:11;59679:159;59707:6;59701:3;:12;59679:159;;;59737:21;59761:8;59770:3;59761:13;;;;;;;;;;;;;;;;;;59737:37;;59812:14;59789:4;:20;;:37;;;;59679:159;59715:5;;;;;59679:159;;;;59861:14;59848:10;:27;;;;59893:28;59910:10;;59893:28;;;;;;;;;;;;;;;;;;12314:1;59367:562:::0;:::o;3281:106::-;3334:15;3369:10;3362:17;;3281:106;:::o;7218:220::-;7276:7;7305:1;7300;:6;7296:20;;;7315:1;7308:8;;;;7296:20;7327:9;7343:1;7339;:5;7327:17;;7372:1;7367;7363;:5;;;;;;:10;7355:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7429:1;7422:8;;;7218:220;;;;;:::o;7916:153::-;7974:7;8006:1;8002;:5;7994:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8060:1;8056;:5;;;;;;8049:12;;7916:153;;;;:::o;6801:158::-;6859:7;6892:1;6887;:6;;6879:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6950:1;6946;:5;6939:12;;6801:158;;;;:::o;57428:433::-;57505:16;57524:5;;;;;;;;;;;:15;;;57548:4;57524:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57505:49;;57565:20;57618:8;57608:7;:18;57604:177;;;57661:5;;;;;;;;;;;:14;;;57676:3;57681:8;57661:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57643:47;;57604:177;;;57741:5;;;;;;;;;;;:14;;;57756:3;57761:7;57741:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57723:46;;57604:177;57799:15;57791:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57428:433;;;;:::o;42755:211::-;42872:86;42892:5;42922:23;;;42947:2;42951:5;42899:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42872:19;:86::i;:::-;42755:211;;;:::o;6339:179::-;6397:7;6417:9;6433:1;6429;:5;6417:17;;6458:1;6453;:6;;6445:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6509:1;6502:8;;;6339:179;;;;:::o;42974:248::-;43118:96;43138:5;43168:27;;;43197:4;43203:2;43207:5;43145:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43118:19;:96::i;:::-;42974:248;;;;:::o;45290:774::-;45714:23;45740:69;45768:4;45740:69;;;;;;;;;;;;;;;;;45748:5;45740:27;;;;:69;;;;;:::i;:::-;45714:95;;45844:1;45824:10;:17;:21;45820:237;;;45979:10;45968:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45960:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45820:237;45290:774;;;:::o;16827:195::-;16930:12;16962:52;16984:6;16992:4;16998:1;17001:12;16962:21;:52::i;:::-;16955:59;;16827:195;;;;;:::o;17879:530::-;18006:12;18064:5;18039:21;:30;;18031:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18131:18;18142:6;18131:10;:18::i;:::-;18123:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18257:12;18271:23;18298:6;:11;;18318:5;18326:4;18298:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18256:75;;;;18349:52;18367:7;18376:10;18388:12;18349:17;:52::i;:::-;18342:59;;;;17879:530;;;;;;:::o;13909:422::-;13969:4;14177:12;14288:7;14276:20;14268:28;;14322:1;14315:4;:8;14308:15;;;13909:422;;;:::o;20419:742::-;20534:12;20563:7;20559:595;;;20594:10;20587:17;;;;20559:595;20728:1;20708:10;:17;:21;20704:439;;;20971:10;20965:17;21032:15;21019:10;21015:2;21011:19;21004:44;20919:148;21114:12;21107:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20419:742;;;;;;:::o
Swarm Source
ipfs://b9938b1d6ed2227454c4c4a71837970a8e22d0e0320467022a914a64ae4644c4
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.