More Info
Private Name Tags
ContractCreator:
Sponsored
Latest 25 from a total of 386 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Deposit | 75019429 | 55 days ago | IN | 0 FTM | 0.0131093 | ||||
Deposit | 75019420 | 55 days ago | IN | 0 FTM | 0.0131093 | ||||
Deposit | 72612695 | 104 days ago | IN | 0 FTM | 0.00236194 | ||||
Withdraw | 67883485 | 205 days ago | IN | 0 FTM | 0.00444914 | ||||
Deposit | 67883437 | 205 days ago | IN | 0 FTM | 0.00272229 | ||||
Deposit | 67883200 | 205 days ago | IN | 0 FTM | 0.00511262 | ||||
Deposit | 66426730 | 243 days ago | IN | 0 FTM | 0.02719174 | ||||
Deposit | 65013626 | 271 days ago | IN | 0 FTM | 0.0209091 | ||||
Deposit | 64390446 | 283 days ago | IN | 0 FTM | 0.01797572 | ||||
Deposit | 63775006 | 294 days ago | IN | 0 FTM | 0.01874713 | ||||
Deposit | 62453504 | 317 days ago | IN | 0 FTM | 0.03561328 | ||||
Deposit | 61153806 | 333 days ago | IN | 0 FTM | 0.06451999 | ||||
Deposit | 60325083 | 344 days ago | IN | 0 FTM | 0.05109625 | ||||
Deposit | 59497445 | 354 days ago | IN | 0 FTM | 0.04718626 | ||||
Deposit | 58382177 | 369 days ago | IN | 0 FTM | 0.00986723 | ||||
Deposit | 58119323 | 373 days ago | IN | 0 FTM | 0.01120244 | ||||
Deposit | 57783402 | 377 days ago | IN | 0 FTM | 0.01948957 | ||||
Deposit | 57307133 | 385 days ago | IN | 0 FTM | 0.0320995 | ||||
Deposit | 56724685 | 394 days ago | IN | 0 FTM | 0.01125961 | ||||
Deposit | 56323868 | 400 days ago | IN | 0 FTM | 0.00862183 | ||||
Deposit | 56078784 | 404 days ago | IN | 0 FTM | 0.01153655 | ||||
Deposit | 55584992 | 411 days ago | IN | 0 FTM | 0.00922101 | ||||
Deposit | 55082607 | 418 days ago | IN | 0 FTM | 0.03745548 | ||||
Deposit | 54614077 | 425 days ago | IN | 0 FTM | 0.01348179 | ||||
Deposit | 54341909 | 429 days ago | IN | 0 FTM | 0.01348179 |
Latest 1 internal transaction
Parent Txn Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
36313903 | 711 days ago | Contract Creation | 0 FTM |
Loading...
Loading
Contract Name:
MasterChef
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2022-04-17 */ // Dependency file: @openzeppelin/contracts/utils/Context.sol // SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) // pragma solidity ^0.8.0; /** * @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 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) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // Dependency file: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/utils/Context.sol"; /** * @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() { _transferOwnership(_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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol) // pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, 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); } // Dependency file: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // Dependency file: @openzeppelin/contracts/token/ERC20/ERC20.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol) // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; // import "@openzeppelin/contracts/utils/Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); 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 {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, _allowances[owner][spender] + 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 {IERC20-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 virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = _allowances[owner][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This 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: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; emit Transfer(from, to, amount); _afterTokenTransfer(from, to, 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: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(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 virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This 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 virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Spend `amount` form the allowance of `owner` toward `spender`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // Dependency file: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol) // pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ 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) { unchecked { 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) { unchecked { 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) { unchecked { // 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) { unchecked { 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) { unchecked { 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) { return a + b; } /** * @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) { 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) { return a * b; } /** * @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. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { 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) { 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) { unchecked { 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. * * 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) { unchecked { 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) { unchecked { require(b > 0, errorMessage); return a % b; } } } // Dependency file: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) // pragma solidity ^0.8.1; /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 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"); (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"); (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"); (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"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // Dependency file: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol) // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 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 SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 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 * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 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' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _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(IERC20 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, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // Dependency file: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol) // pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } } // Dependency file: contracts/Vault.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/utils/math/Math.sol"; // import "@openzeppelin/contracts/utils/math/SafeMath.sol"; interface IBurnable { function burn(address _owner, uint256 _amount) external; } contract Vault { using SafeMath for uint256; address public immutable pomToken; address public immutable xPomToken; mapping(address => uint256) public balanceOf; event Deposited(address indexed owner, uint256 indexed amount); event Withdrawn(address indexed owner, uint256 indexed amount); constructor(address _pomToken, address _xPomToken) { pomToken = _pomToken; xPomToken = _xPomToken; } function deposit(address _depositor, uint256 _amount) external { balanceOf[_depositor] = balanceOf[_depositor].add(_amount); IERC20(pomToken).transferFrom(msg.sender, address(this), _amount); emit Deposited(_depositor, _amount); } function withdraw() external { uint256 _amount = Math.min(IERC20(xPomToken).balanceOf(msg.sender), balanceOf[msg.sender]); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); IBurnable(xPomToken).burn(msg.sender, _amount); IERC20(pomToken).transfer(msg.sender, _amount); emit Withdrawn(msg.sender, _amount); } } // Dependency file: contracts/PomToken.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // Check the signature length if (signature.length != 65) { revert("ECDSA: invalid signature length"); } // Divide the signature in r, s and v variables bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. // solhint-disable-next-line no-inline-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return recover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. require( uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value" ); require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value"); // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); require(signer != address(0), "ECDSA: invalid signature"); return signer; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (block.chainid == _CACHED_CHAIN_ID) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 name, bytes32 version ) private view returns (bytes32) { return keccak256(abi.encode(typeHash, name, version, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } } /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } } // This version of ERC20Permit is from OpenZeppelin as of commit // https://github.com/OpenZeppelin/openzeppelin-contracts/commit/5171e46c47bd6be781aa92315944ca37126d4a73 /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { // solhint-disable-next-line not-rely-on-time require(block.timestamp <= deadline, "ERC20Permit: expired deadline"); bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } } contract PomToken is ERC20Permit { constructor() ERC20("PomToken", "POM") ERC20Permit("PomToken") { _mint(msg.sender, 3_000_000e18); _moveDelegates(address(0), msg.sender, 3_000_000e18); } // 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 // 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)"); // 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); function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { bool result = super.transferFrom(sender, recipient, amount); // Call parent hook _moveDelegates(sender, recipient, amount); return result; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { bool result = super.transfer(recipient, amount); // Call parent hook _moveDelegates(_msgSender(), recipient, amount); return result; } /** * @param delegator The address to get delegates 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), "POM::delegateBySig: invalid signature"); require(nonce == _useNonce(signatory), "POM::delegateBySig: invalid nonce"); require(block.timestamp <= expiry, "POM::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, "POM::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 POMs (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 - 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 + amount; _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32(block.number, "POM::_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 view returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } // Root file: contracts/MasterChef.sol pragma solidity ^0.8.0; // import "@openzeppelin/contracts/access/Ownable.sol"; // import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; // import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // import "@openzeppelin/contracts/utils/math/SafeMath.sol"; // import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; // import "contracts/Vault.sol"; // import "contracts/PomToken.sol"; interface ILendPool is IERC20 { function mint(uint mintAmount) external returns (uint); function redeem(uint redeemTokens) external returns (uint); function redeemUnderlying(uint redeemAmount) external returns (uint); } // MasterChef support token which deposited into iron bank only!!!! contract MasterChef is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // 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 POMs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accPomPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accPomPerShare` (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 { IERC20 lpToken; // Address of LP token contract. ILendPool lendPool; uint256 deposited; // Total deposited in this pool uint256 allocPoint; // How many allocation points assigned to this pool. POMs to distribute per block. uint256 depositFee; uint256 lastRewardTime; // Last block time that POMs distribution occurs. uint256 accPomPerShare; // Accumulated POMs per share, times 1e12. See below. } // Pom reward vault Vault public vault; // such a pom token! PomToken public pom; // Dev address. address public devaddr; // pom tokens created per second. uint256 public pomPerSecond; // set a max pom per second, which can never be higher than 1 per second uint256 public constant maxBooPerSecond = 1e18; uint256 private constant MaxAllocPoint = 4000; uint256 private constant MaxDepositFee = 500; // 5% uint256 private constant MaxDivisionAmount = 10000; // 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 time when pom mining starts. uint256 public immutable startTime; 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); constructor( Vault _vault, PomToken _pom, address _devaddr, uint256 _pomPerSecond, uint256 _startTime ) { vault = _vault; pom = _pom; devaddr = _devaddr; pomPerSecond = _pomPerSecond; startTime = _startTime; } function poolLength() external view returns (uint256) { return poolInfo.length; } // Changes pom token reward per second, with a cap of max POM per second // Good practice to update pools without messing up the contract function setPomPerSecond(uint256 _pomPerSecond) external onlyOwner { require(_pomPerSecond <= maxBooPerSecond, "setPomPerSecond: too many poms!"); // This MUST be done or pool rewards will be calculated with new pom per second // This could unfairly punish small pools that dont have frequent deposits/withdraws/harvests massUpdatePools(); pomPerSecond = _pomPerSecond; } function checkForDuplicate(IERC20 _lpToken) internal view { uint256 length = poolInfo.length; for (uint256 _pid = 0; _pid < length; _pid++) { require(poolInfo[_pid].lpToken != _lpToken, "add: pool already exists!!!!"); } } // Add a new lp to the pool. Can only be called by the owner. function add( uint256 _allocPoint, uint256 _depositFee, IERC20 _lpToken, ILendPool _lendPool ) external onlyOwner { require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!"); require(_depositFee <= MaxDepositFee, "add: too many fees!!"); checkForDuplicate(_lpToken); // ensure you cant add duplicate pools massUpdatePools(); uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, lendPool: _lendPool, deposited: 0, allocPoint: _allocPoint, depositFee: _depositFee, lastRewardTime: lastRewardTime, accPomPerShare: 0 }) ); } // Update the given pool's pom allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint) external onlyOwner { require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!"); massUpdatePools(); totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint; poolInfo[_pid].allocPoint = _allocPoint; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { _from = _from > startTime ? _from : startTime; if (_to < startTime) { return 0; } return _to - _from; } // View function to see pending POMs on frontend. function pendingPom(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accPomPerShare = pool.accPomPerShare; uint256 lpSupply = pool.deposited; if (block.timestamp > pool.lastRewardTime && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp); uint256 pomReward = multiplier.mul(pomPerSecond).mul(pool.allocPoint).div(totalAllocPoint); accPomPerShare = accPomPerShare.add(pomReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accPomPerShare).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.timestamp <= pool.lastRewardTime) { return; } uint256 lpSupply = pool.deposited; if (lpSupply == 0) { pool.lastRewardTime = block.timestamp; return; } uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp); uint256 pomReward = multiplier.mul(pomPerSecond).mul(pool.allocPoint).div(totalAllocPoint); pom.transfer(devaddr, pomReward.div(10)); pool.accPomPerShare = pool.accPomPerShare.add(pomReward.mul(1e12).div(lpSupply)); pool.lastRewardTime = block.timestamp; } // Deposit LP tokens to MasterChef for pom allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accPomPerShare).div(1e12).sub(user.rewardDebt); uint256 balanceBefore = pool.lpToken.balanceOf(address(this)); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); pool.lpToken.safeTransfer(devaddr, _amount.mul(pool.depositFee).div(MaxDivisionAmount)); _amount = pool.lpToken.balanceOf(address(this)).sub(balanceBefore); pool.deposited = pool.deposited.add(_amount); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accPomPerShare).div(1e12); if (pending > 0) { safePomTransfer(_pid, msg.sender, pending); } if (address(pool.lendPool) != address(0)) { // deposit token into ib.xyz lending pool pool.lpToken.approve(address(pool.lendPool), 0); pool.lpToken.approve(address(pool.lendPool), _amount); pool.lendPool.mint(_amount); } emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from MasterChef. function withdraw(uint256 _pid, uint256 _amount) public { 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.accPomPerShare).div(1e12).sub(user.rewardDebt); uint256 shareNeedToWithdraw; if (address(pool.lendPool) != address(0)) { // calculate amount need to withdraw from lend pool shareNeedToWithdraw = _amount.mul(IERC20(address(pool.lendPool)).balanceOf(address(this))).div( pool.deposited ); } pool.deposited = pool.deposited.sub(_amount); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accPomPerShare).div(1e12); if (pending > 0) { safePomTransfer(_pid, msg.sender, pending); } if (address(pool.lendPool) == address(0)) { pool.lpToken.safeTransfer(address(msg.sender), _amount); } else { pool.lendPool.redeem(shareNeedToWithdraw); uint256 underlyingRedeemed = pool.lpToken.balanceOf(address(this)); uint256 yieldAmount = underlyingRedeemed > _amount ? underlyingRedeemed.sub(_amount) : 0; _amount = Math.min(_amount, underlyingRedeemed); pool.lpToken.safeTransfer(devaddr, _amount); pool.lpToken.safeTransfer(address(msg.sender), yieldAmount); } emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; // calculate amount need to withdraw from lend pool uint256 shareNeedToWithdraw; if (address(pool.lendPool) != address(0)) { shareNeedToWithdraw = user.amount.mul(IERC20(address(pool.lendPool)).balanceOf(address(this))).div( pool.deposited ); } uint oldUserAmount = user.amount; pool.deposited = pool.deposited.sub(user.amount); user.amount = 0; user.rewardDebt = 0; if (address(pool.lendPool) == address(0)) { pool.lpToken.safeTransfer(address(msg.sender), oldUserAmount); } else { pool.lendPool.redeem(shareNeedToWithdraw); uint256 underlyingRedeemed = pool.lpToken.balanceOf(address(this)); uint256 yieldAmount = underlyingRedeemed > oldUserAmount ? underlyingRedeemed.sub(oldUserAmount) : 0; uint256 amount = Math.min(oldUserAmount, underlyingRedeemed); pool.lpToken.safeTransfer(devaddr, yieldAmount); pool.lpToken.safeTransfer(address(msg.sender), amount); } emit EmergencyWithdraw(msg.sender, _pid, oldUserAmount); } // Safe pom transfer function, just in case if rounding error causes pool to not have enough POMs. function safePomTransfer( uint256 _pid, address _to, uint256 _amount ) internal { uint256 pomBal = pom.balanceOf(address(this)); if (_amount > pomBal) { _amount = pomBal; } if (poolInfo[_pid].depositFee == 0) { pom.transfer(_to, _amount); } else { // Transfer pom to vault IERC20(address(pom)).approve(address(vault), 0); IERC20(address(pom)).approve(address(vault), _amount); vault.deposit(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract Vault","name":"_vault","type":"address"},{"internalType":"contract PomToken","name":"_pom","type":"address"},{"internalType":"address","name":"_devaddr","type":"address"},{"internalType":"uint256","name":"_pomPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","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":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint256","name":"_depositFee","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract ILendPool","name":"_lendPool","type":"address"}],"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":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"dev","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":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxBooPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"pendingPom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pom","outputs":[{"internalType":"contract PomToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pomPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"contract ILendPool","name":"lendPool","type":"address"},{"internalType":"uint256","name":"deposited","type":"uint256"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"depositFee","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accPomPerShare","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":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pomPerSecond","type":"uint256"}],"name":"setPomPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","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":"_pid","type":"uint256"}],"name":"updatePool","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":[],"name":"vault","outputs":[{"internalType":"contract Vault","name":"","type":"address"}],"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)
000000000000000000000000109fbfb5640e0f886b07c044f48344f689dc70c700000000000000000000000072f8fbdc80410c1ae583fbf3c5cd190a39194c8400000000000000000000000005a2d658c587e0ce3c6f0ec4e1dd42c0a79b747e00000000000000000000000000000000000000000000000000e470e2338fa00000000000000000000000000000000000000000000000000000000000625ece70
-----Decoded View---------------
Arg [0] : _vault (address): 0x109fbfb5640e0F886b07c044f48344F689dC70C7
Arg [1] : _pom (address): 0x72F8FBDc80410C1AE583fBF3c5cD190a39194c84
Arg [2] : _devaddr (address): 0x05a2D658c587E0CE3c6f0Ec4e1DD42C0A79b747e
Arg [3] : _pomPerSecond (uint256): 64300411520000000
Arg [4] : _startTime (uint256): 1650380400
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000109fbfb5640e0f886b07c044f48344f689dc70c7
Arg [1] : 00000000000000000000000072f8fbdc80410c1ae583fbf3c5cd190a39194c84
Arg [2] : 00000000000000000000000005a2d658c587e0ce3c6f0ec4e1dd42c0a79b747e
Arg [3] : 00000000000000000000000000000000000000000000000000e470e2338fa000
Arg [4] : 00000000000000000000000000000000000000000000000000000000625ece70
Deployed Bytecode Sourcemap
67974:12782:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70926:95;70998:8;:15;70926:95;;;9302:25:1;;;9290:2;9275:18;70926:95:0;;;;;;;;69617:27;;;;;;69981:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3973:15:1;;;3955:34;;4025:15;;;;4020:2;4005:18;;3998:43;4057:18;;;4050:34;;;;4115:2;4100:18;;4093:34;;;;4158:3;4143:19;;4136:35;3935:3;4187:19;;4180:35;4246:3;4231:19;;4224:35;3904:3;3889:19;69981:26:0;3871:394:1;70226:34:0;;;;;;72976:323;;;;;;:::i;:::-;;:::i;:::-;;76848:1615;;;;;;:::i;:::-;;:::i;73678:732::-;;;;;;:::i;:::-;;:::i;74749:721::-;;;;;;:::i;:::-;;:::i;78534:1342::-;;;;;;:::i;:::-;;:::i;69498:19::-;;;;;-1:-1:-1;;;;;69498:19:0;;;;;;-1:-1:-1;;;;;2580:32:1;;;2562:51;;2550:2;2535:18;69498:19:0;2517:102:1;74493:180:0;;;:::i;71177:425::-;;;;;;:::i;:::-;;:::i;2721:103::-;;;:::i;70316:34::-;;;;;71952:929;;;;;;:::i;:::-;;:::i;80624:129::-;;;;;;:::i;:::-;;:::i;2070:87::-;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;2070:87;;73375:240;;;;;;:::i;:::-;;:::i;70065:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9512:25:1;;;9568:2;9553:18;;9546:34;;;;9485:18;70065:64:0;9467:119:1;69731:46:0;;69773:4;69731:46;;69547:22;;;;;-1:-1:-1;;;;;69547:22:0;;;75538:1258;;;;;;:::i;:::-;;:::i;2979:201::-;;;;;;:::i;:::-;;:::i;69445:18::-;;;;;-1:-1:-1;;;;;69445:18:0;;;69981:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69981:26:0;;;;-1:-1:-1;69981:26:0;;;;;;;;;;;;:::o;72976:323::-;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;804:10;2290:23;2282:68;;;;-1:-1:-1;;;2282:68:0;;;;;;;:::i;:::-;;;;;;;;;69827:4:::1;73062:11;:28;;73054:69;;;::::0;-1:-1:-1;;;73054:69:0;;8590:2:1;73054:69:0::1;::::0;::::1;8572:21:1::0;8629:2;8609:18;;;8602:30;8668;8648:18;;;8641:58;8716:18;;73054:69:0::1;8562:178:1::0;73054:69:0::1;73136:17;:15;:17::i;:::-;73230:11;73202:8;73211:4;73202:14;;;;;;-1:-1:-1::0;;;73202:14:0::1;;;;;;;;;;;;;;;;;;;:25;;;73184:15;;:43;;;;:::i;:::-;:57;;;;:::i;:::-;73166:15;:75;;;;73280:11;73252:8;73261:4;73252:14;;;;;;-1:-1:-1::0;;;73252:14:0::1;;;;;;;;;;;;;;;;;;;:25;;:39;;;;72976:323:::0;;:::o;76848:1615::-;76915:21;76939:8;76948:4;76939:14;;;;;;-1:-1:-1;;;76939:14:0;;;;;;;;;;;;;;;;;76988;;;:8;:14;;;;;;77003:10;76988:26;;;;;;;77035:11;;76939:14;;;;;;;;-1:-1:-1;77035:22:0;-1:-1:-1;77035:22:0;77027:53;;;;-1:-1:-1;;;77027:53:0;;8243:2:1;77027:53:0;;;8225:21:1;8282:2;8262:18;;;8255:30;-1:-1:-1;;;8301:18:1;;;8294:48;8359:18;;77027:53:0;8215:168:1;77027:53:0;77093:16;77104:4;77093:10;:16::i;:::-;77122:15;77140:67;77191:4;:15;;;77140:46;77181:4;77140:36;77156:4;:19;;;77140:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46::i;:::-;:50;;:67::i;:::-;77270:13;;;;77122:85;;-1:-1:-1;77220:27:0;;-1:-1:-1;;;;;77270:13:0;77262:36;77258:276;;77493:14;;;;77429:13;;;;77414:55;;-1:-1:-1;;;77414:55:0;;77463:4;77414:55;;;2562:51:1;77402:120:0;;77493:14;77402:68;;-1:-1:-1;;;;;77429:13:0;;;;77414:40;;2535:18:1;;77414:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77402:7;;:11;:68::i;:120::-;77380:142;;77258:276;77563:14;;;;:27;;77582:7;77563:18;:27::i;:::-;77546:14;;;:44;77615:11;;:24;;77631:7;77615:15;:24::i;:::-;77601:38;;;77684:19;;;;77668:46;;77709:4;;77668:36;;77601:38;77668:15;:36::i;:46::-;77650:15;;;:64;77731:11;;77727:86;;77759:42;77775:4;77781:10;77793:7;77759:15;:42::i;:::-;77837:13;;;;-1:-1:-1;;;;;77837:13:0;77825:578;;77882:12;;:55;;-1:-1:-1;;;;;77882:12:0;77916:10;77929:7;77882:25;:55::i;:::-;77825:578;;;77970:13;;;;:41;;-1:-1:-1;;;77970:41:0;;;;;9302:25:1;;;-1:-1:-1;;;;;77970:13:0;;;;:20;;9275:18:1;;77970:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;78055:12:0;;:37;;-1:-1:-1;;;78055:37:0;;78086:4;78055:37;;;2562:51:1;78026:26:0;;-1:-1:-1;;;;;78055:12:0;;:22;;2535:18:1;;78055:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78026:66;;78107:19;78150:7;78129:18;:28;:66;;78194:1;78129:66;;;78160:31;:18;78183:7;78160:22;:31::i;:::-;78107:88;;78220:37;78229:7;78238:18;78220:8;:37::i;:::-;78300:7;;78274:12;;78210:47;;-1:-1:-1;78274:43:0;;-1:-1:-1;;;;;78274:12:0;;;;78300:7;78210:47;78274:25;:43::i;:::-;78332:12;;:59;;-1:-1:-1;;;;;78332:12:0;78366:10;78379:11;78332:25;:59::i;:::-;77825:578;;;78420:35;;9302:25:1;;;78441:4:0;;78429:10;;78420:35;;9290:2:1;9275:18;78420:35:0;;;;;;;;76848:1615;;;;;;:::o;73678:732::-;73750:7;73770:21;73794:8;73803:4;73794:14;;;;;;-1:-1:-1;;;73794:14:0;;;;;;;;;;;;;;;;;73843;;;:8;:14;;;;;;;-1:-1:-1;;;;;73843:21:0;;;;;;;;;;;73794:14;;;;;;;73900:19;;;;73949:14;;;;73996:19;;;;73794:14;;-1:-1:-1;73843:21:0;;73900:19;;73949:14;73978:15;:37;:54;;;;-1:-1:-1;74019:13:0;;;73978:54;73974:349;;;74049:18;74070:51;74084:4;:19;;;74105:15;74070:13;:51::i;:::-;74049:72;;74136:17;74156:70;74210:15;;74156:49;74189:4;:15;;;74156:28;74171:12;;74156:10;:14;;:28;;;;:::i;:::-;:32;;:49::i;:70::-;74136:90;-1:-1:-1;74258:53:0;74277:33;74301:8;74277:19;74136:90;74291:4;74277:13;:19::i;:33::-;74258:14;;:18;:53::i;:::-;74241:70;;73974:349;;;74340:62;74386:4;:15;;;74340:41;74376:4;74340:31;74356:14;74340:4;:11;;;:15;;:31;;;;:::i;:62::-;74333:69;;;;;;73678:732;;;;;:::o;74749:721::-;74801:21;74825:8;74834:4;74825:14;;;;;;-1:-1:-1;;;74825:14:0;;;;;;;;;;;;;;;;;;;74801:38;;74873:4;:19;;;74854:15;:38;74850:77;;74909:7;74749:721;:::o;74850:77::-;74956:14;;;;74985:13;74981:104;;-1:-1:-1;75037:15:0;75015:19;;;;:37;-1:-1:-1;74749:721:0:o;74981:104::-;75095:18;75116:51;75130:4;:19;;;75151:15;75116:13;:51::i;:::-;75095:72;;75178:17;75198:70;75252:15;;75198:49;75231:4;:15;;;75198:28;75213:12;;75198:10;:14;;:28;;;;:::i;:70::-;75281:3;;75294:7;;75178:90;;-1:-1:-1;;;;;;75281:3:0;;;;:12;;75294:7;75303:17;75178:90;75317:2;75303:13;:17::i;:::-;75281:40;;-1:-1:-1;;;;;;75281:40:0;;;;;;;-1:-1:-1;;;;;3204:32:1;;;75281:40:0;;;3186:51:1;3253:18;;;3246:34;3159:18;;75281:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;75356:58:0;75380:33;75404:8;75380:19;:9;75394:4;75380:13;:19::i;:33::-;75356:19;;;;;:23;:58::i;:::-;75334:19;;;:80;-1:-1:-1;;75447:15:0;75425:19;;;;:37;;;;-1:-1:-1;;74749:721:0:o;78534:1342::-;78593:21;78617:8;78626:4;78617:14;;;;;;-1:-1:-1;;;78617:14:0;;;;;;;;;;;;;;;;;78666;;;:8;:14;;;;;;78681:10;78666:26;;;;;;;;78617:14;;;;;;78818:13;;;;78617:14;;-1:-1:-1;78666:26:0;;78617:14;-1:-1:-1;;;;;78818:13:0;78810:36;78806:215;;78980:14;;;;78916:13;;;;78901:55;;-1:-1:-1;;;78901:55:0;;78950:4;78901:55;;;2562:51:1;78885:124:0;;78980:14;78885:72;;-1:-1:-1;;;;;78916:13:0;;;;78901:40;;2535:18:1;;78901:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78885:11;;;:15;:72::i;:124::-;78863:146;;78806:215;79054:11;;79093:14;;;;:31;;79054:11;79093:18;:31::i;:::-;79076:14;;;:48;79149:1;79135:15;;;79161;;;;:19;;;;79205:13;;;-1:-1:-1;;;;;79205:13:0;79193:608;;79250:12;;:61;;-1:-1:-1;;;;;79250:12:0;79284:10;79297:13;79250:25;:61::i;:::-;79193:608;;;79344:13;;;;:41;;-1:-1:-1;;;79344:41:0;;;;;9302:25:1;;;-1:-1:-1;;;;;79344:13:0;;;;:20;;9275:18:1;;79344:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;79429:12:0;;:37;;-1:-1:-1;;;79429:37:0;;79460:4;79429:37;;;2562:51:1;79400:26:0;;-1:-1:-1;;;;;79429:12:0;;:22;;2535:18:1;;79429:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79400:66;;79481:19;79524:13;79503:18;:34;:78;;79580:1;79503:78;;;79540:37;:18;79563:13;79540:22;:37::i;:::-;79481:100;;79596:14;79613:43;79622:13;79637:18;79613:8;:43::i;:::-;79699:7;;79673:12;;79596:60;;-1:-1:-1;79673:47:0;;-1:-1:-1;;;;;79673:12:0;;;;79699:7;79708:11;79673:25;:47::i;:::-;79735:12;;:54;;-1:-1:-1;;;;;79735:12:0;79769:10;79782:6;79735:25;:54::i;:::-;79193:608;;;;79818:50;;9302:25:1;;;79848:4:0;;79836:10;;79818:50;;9290:2:1;9275:18;79818:50:0;;;;;;;78534:1342;;;;;:::o;74493:180::-;74555:8;:15;74538:14;74581:85;74609:6;74603:3;:12;74581:85;;;74639:15;74650:3;74639:10;:15::i;:::-;74617:5;;;:::i;:::-;;;74581:85;;;;74493:180;:::o;71177:425::-;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;804:10;2290:23;2282:68;;;;-1:-1:-1;;;2282:68:0;;;;;;;:::i;:::-;69773:4:::1;71263:13;:32;;71255:76;;;::::0;-1:-1:-1;;;71255:76:0;;7525:2:1;71255:76:0::1;::::0;::::1;7507:21:1::0;7564:2;7544:18;;;7537:30;7603:33;7583:18;;;7576:61;7654:18;;71255:76:0::1;7497:181:1::0;71255:76:0::1;71536:17;:15;:17::i;:::-;71566:12;:28:::0;71177:425::o;2721:103::-;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;804:10;2290:23;2282:68;;;;-1:-1:-1;;;2282:68:0;;;;;;;:::i;:::-;2786:30:::1;2813:1;2786:18;:30::i;:::-;2721:103::o:0;71952:929::-;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;804:10;2290:23;2282:68;;;;-1:-1:-1;;;2282:68:0;;;;;;;:::i;:::-;69827:4:::1;72126:11;:28;;72118:69;;;::::0;-1:-1:-1;;;72118:69:0;;8590:2:1;72118:69:0::1;::::0;::::1;8572:21:1::0;8629:2;8609:18;;;8602:30;8668;8648:18;;;8641:58;8716:18;;72118:69:0::1;8562:178:1::0;72118:69:0::1;69879:3;72206:11;:28;;72198:61;;;::::0;-1:-1:-1;;;72198:61:0;;5307:2:1;72198:61:0::1;::::0;::::1;5289:21:1::0;5346:2;5326:18;;;5319:30;-1:-1:-1;;;5365:18:1;;;5358:50;5425:18;;72198:61:0::1;5279:170:1::0;72198:61:0::1;72272:27;72290:8;72272:17;:27::i;:::-;72351:17;:15;:17::i;:::-;72381:22;72424:9;72406:15;:27;:57;;72454:9;72406:57;;;72436:15;72406:57;72492:15;::::0;72381:82;;-1:-1:-1;72492:32:0::1;::::0;72512:11;72492:19:::1;:32::i;:::-;72474:15;:50:::0;;;72563:299:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;72563:299:0;;::::1;::::0;;;;::::1;;::::0;::::1;::::0;;;-1:-1:-1;72563:299:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72535:8:::1;:338:::0;;::::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;;72535:338:0;;::::1;;::::0;;;;;;;;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71952:929::o;80624:129::-;80695:7;;-1:-1:-1;;;;;80695:7:0;80681:10;:21;80673:43;;;;-1:-1:-1;;;80673:43:0;;6827:2:1;80673:43:0;;;6809:21:1;6866:1;6846:18;;;6839:29;-1:-1:-1;;;6884:18:1;;;6877:39;6933:18;;80673:43:0;6799:158:1;80673:43:0;80727:7;:18;;-1:-1:-1;;;;;;80727:18:0;-1:-1:-1;;;;;80727:18:0;;;;;;;;;;80624:129::o;73375:240::-;73447:7;73483:9;73475:5;:17;:37;;73503:9;73475:37;;;73495:5;73475:37;73467:45;;73533:9;73527:3;:15;73523:56;;;-1:-1:-1;73566:1:0;73559:8;;73523:56;73596:11;73602:5;73596:3;:11;:::i;:::-;73589:18;73375:240;-1:-1:-1;;;73375:240:0:o;75538:1258::-;75604:21;75628:8;75637:4;75628:14;;;;;;-1:-1:-1;;;75628:14:0;;;;;;;;;;;;;;;;;75677;;;:8;:14;;;;;;75692:10;75677:26;;;;;;;75628:14;;;;;;;;-1:-1:-1;75716:16:0;75686:4;75716:10;:16::i;:::-;75745:15;75763:67;75814:4;:15;;;75763:46;75804:4;75763:36;75779:4;:19;;;75763:4;:11;;;:15;;:36;;;;:::i;:67::-;75867:12;;:37;;-1:-1:-1;;;75867:37:0;;75898:4;75867:37;;;2562:51:1;75745:85:0;;-1:-1:-1;75843:21:0;;-1:-1:-1;;;;;75867:12:0;;;;:22;;2535:18:1;;75867:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75915:12;;75843:61;;-1:-1:-1;75915:74:0;;-1:-1:-1;;;;;75915:12:0;75953:10;75974:4;75981:7;75915:29;:74::i;:::-;76026:7;;76047:15;;;;76000:87;;-1:-1:-1;;;;;76026:7:0;;76035:51;;69940:5;;76035:28;;:7;;:11;:28::i;:51::-;76000:12;;-1:-1:-1;;;;;76000:12:0;;:87;:25;:87::i;:::-;76108:12;;:37;;-1:-1:-1;;;76108:37:0;;76139:4;76108:37;;;2562:51:1;76108:56:0;;76150:13;;-1:-1:-1;;;;;76108:12:0;;;;:22;;2535:18:1;;76108:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:56::-;76194:14;;;;76098:66;;-1:-1:-1;76194:27:0;;76098:66;76194:18;:27::i;:::-;76177:14;;;:44;76246:11;;:24;;76262:7;76246:15;:24::i;:::-;76232:38;;;76315:19;;;;76299:46;;76340:4;;76299:36;;76232:38;76299:15;:36::i;:46::-;76281:15;;;:64;76362:11;;76358:86;;76390:42;76406:4;76412:10;76424:7;76390:15;:42::i;:::-;76468:13;;;;-1:-1:-1;;;;;76468:13:0;76460:36;76456:281;;76568:12;;;76597:13;;;76568:47;;-1:-1:-1;;;76568:47:0;;-1:-1:-1;;;;;76597:13:0;;;76568:47;;;3186:51:1;76568:12:0;3253:18:1;;;3246:34;76568:12:0;;;:20;;3159:18:1;;76568:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;76630:12:0;;;76659:13;;;76630:53;;-1:-1:-1;;;76630:53:0;;-1:-1:-1;;;;;76659:13:0;;;76630:53;;;3186:51:1;3253:18;;;3246:34;;;76630:12:0;;;:20;;3159:18:1;;76630:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;76698:13:0;;;;:27;;-1:-1:-1;;;76698:27:0;;;;;9302:25:1;;;-1:-1:-1;;;;;76698:13:0;;;;:18;;9275::1;;76698:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;76456:281;76754:34;;9302:25:1;;;76774:4:0;;76762:10;;76754:34;;9290:2:1;9275:18;76754:34:0;9257:76:1;2979:201:0;2116:7;2143:6;-1:-1:-1;;;;;2143:6:0;804:10;2290:23;2282:68;;;;-1:-1:-1;;;2282:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3068:22:0;::::1;3060:73;;;::::0;-1:-1:-1;;;3060:73:0;;5656:2:1;3060:73:0::1;::::0;::::1;5638:21:1::0;5695:2;5675:18;;;5668:30;5734:34;5714:18;;;5707:62;-1:-1:-1;;;5785:18:1;;;5778:36;5831:19;;3060:73:0::1;5628:228:1::0;3060:73:0::1;3144:28;3163:8;3144:18;:28::i;:::-;2979:201:::0;:::o;24003:98::-;24061:7;24088:5;24092:1;24088;:5;:::i;24402:98::-;24460:7;24487:5;24491:1;24487;:5;:::i;23646:98::-;23704:7;23731:5;23735:1;23731;:5;:::i;79988:580::-;80128:3;;:28;;-1:-1:-1;;;80128:28:0;;80150:4;80128:28;;;2562:51:1;80111:14:0;;-1:-1:-1;;;;;80128:3:0;;:13;;2535:18:1;;80128:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80111:45;;80181:6;80171:7;:16;80167:65;;;80214:6;80204:16;;80167:65;80248:8;80257:4;80248:14;;;;;;-1:-1:-1;;;80248:14:0;;;;;;;;;;;;;;;;;;;:25;;;80277:1;80248:30;80244:317;;;80295:3;;:26;;-1:-1:-1;;;80295:26:0;;-1:-1:-1;;;;;3204:32:1;;;80295:26:0;;;3186:51:1;3253:18;;;3246:34;;;80295:3:0;;;;:12;;3159:18:1;;80295:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;80244:317;;;80407:3;;;80429:5;80392:47;;-1:-1:-1;;;80392:47:0;;-1:-1:-1;;;;;80429:5:0;;;80392:47;;;3186:51:1;80407:3:0;3253:18:1;;;3246:34;80407:3:0;;;80392:28;;3159:18:1;;80392:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;80469:3:0;;;80491:5;80454:53;;-1:-1:-1;;;80454:53:0;;-1:-1:-1;;;;;80491:5:0;;;80454:53;;;3186:51:1;3253:18;;;3246:34;;;80469:3:0;;;80454:28;;3159:18:1;;80454:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;80522:5:0;;:27;;-1:-1:-1;;;80522:27:0;;-1:-1:-1;;;;;3204:32:1;;;80522:27:0;;;3186:51:1;3253:18;;;3246:34;;;80522:5:0;;;;:13;;3159:18:1;;80522:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80244:317;79988:580;;;;:::o;36773:211::-;36917:58;;-1:-1:-1;;;;;3204:32:1;;36917:58:0;;;3186:51:1;3253:18;;;3246:34;;;36890:86:0;;36910:5;;-1:-1:-1;;;36940:23:0;3159:18:1;;36917:58:0;;;;-1:-1:-1;;36917:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;36917:58:0;-1:-1:-1;;;;;;36917:58:0;;;;;;;;;;36890:19;:86::i;:::-;36773:211;;;:::o;40588:106::-;40646:7;40677:1;40673;:5;:13;;40685:1;40673:13;;;-1:-1:-1;40681:1:0;;40588:106;-1:-1:-1;40588:106:0:o;23265:98::-;23323:7;23350:5;23354:1;23350;:5;:::i;3340:191::-;3414:16;3433:6;;-1:-1:-1;;;;;3450:17:0;;;-1:-1:-1;;;;;;3450:17:0;;;;;;3483:40;;3433:6;;;;;;;3483:40;;3414:16;3483:40;3340:191;;:::o;71610:267::-;71696:8;:15;71679:14;71722:148;71752:6;71745:4;:13;71722:148;;;71817:8;-1:-1:-1;;;;;71791:34:0;:8;71800:4;71791:14;;;;;;-1:-1:-1;;;71791:14:0;;;;;;;;;;;;;;;;;;;;;;:22;-1:-1:-1;;;;;71791:22:0;:34;;71783:75;;;;-1:-1:-1;;;71783:75:0;;6470:2:1;71783:75:0;;;6452:21:1;6509:2;6489:18;;;6482:30;6548;6528:18;;;6521:58;6596:18;;71783:75:0;6442:178:1;71783:75:0;71760:6;;;;:::i;:::-;;;;71722:148;;36992:248;37163:68;;-1:-1:-1;;;;;2882:15:1;;;37163:68:0;;;2864:34:1;2934:15;;2914:18;;;2907:43;2966:18;;;2959:34;;;37136:96:0;;37156:5;;-1:-1:-1;;;37186:27:0;2799:18:1;;37163:68:0;2781:218:1;39346:716:0;39770:23;39796:69;39824:4;39796:69;;;;;;;;;;;;;;;;;39804:5;-1:-1:-1;;;;;39796:27:0;;;:69;;;;;:::i;:::-;39880:17;;39770:95;;-1:-1:-1;39880:21:0;39876:179;;39977:10;39966:30;;;;;;;;;;;;:::i;:::-;39958:85;;;;-1:-1:-1;;;39958:85:0;;8947:2:1;39958:85:0;;;8929:21:1;8986:2;8966:18;;;8959:30;9025:34;9005:18;;;8998:62;-1:-1:-1;;;9076:18:1;;;9069:40;9126:19;;39958:85:0;8919:232:1;31422:229:0;31559:12;31591:52;31613:6;31621:4;31627:1;31630:12;31591:21;:52::i;:::-;31584:59;31422:229;-1:-1:-1;;;;31422:229:0:o;32542:510::-;32712:12;32770:5;32745:21;:30;;32737:81;;;;-1:-1:-1;;;32737:81:0;;6063:2:1;32737:81:0;;;6045:21:1;6102:2;6082:18;;;6075:30;6141:34;6121:18;;;6114:62;-1:-1:-1;;;6192:18:1;;;6185:36;6238:19;;32737:81:0;6035:228:1;32737:81:0;-1:-1:-1;;;;;28972:19:0;;;32829:60;;;;-1:-1:-1;;;32829:60:0;;7885:2:1;32829:60:0;;;7867:21:1;7924:2;7904:18;;;7897:30;7963:31;7943:18;;;7936:59;8012:18;;32829:60:0;7857:179:1;32829:60:0;32903:12;32917:23;32944:6;-1:-1:-1;;;;;32944:11:0;32963:5;32970:4;32944:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32902:73;;;;32993:51;33010:7;33019:10;33031:12;32993:16;:51::i;:::-;32986:58;32542:510;-1:-1:-1;;;;;;;32542:510:0:o;35228:712::-;35378:12;35407:7;35403:530;;;-1:-1:-1;35438:10:0;35431:17;;35403:530;35552:17;;:21;35548:374;;35750:10;35744:17;35811:15;35798:10;35794:2;35790:19;35783:44;35698:148;35893:12;35886:20;;-1:-1:-1;;;35886:20:0;;;;;;;;:::i;14:257:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:31;235:5;210:31;:::i;276:297::-;343:6;396:2;384:9;375:7;371:23;367:32;364:2;;;417:6;409;402:22;364:2;454:9;448:16;507:5;500:13;493:21;486:5;483:32;473:2;;534:6;526;519:22;578:190;637:6;690:2;678:9;669:7;665:23;661:32;658:2;;;711:6;703;696:22;658:2;-1:-1:-1;739:23:1;;648:120;-1:-1:-1;648:120:1:o;773:194::-;843:6;896:2;884:9;875:7;871:23;867:32;864:2;;;917:6;909;902:22;864:2;-1:-1:-1;945:16:1;;854:113;-1:-1:-1;854:113:1:o;972:325::-;1040:6;1048;1101:2;1089:9;1080:7;1076:23;1072:32;1069:2;;;1122:6;1114;1107:22;1069:2;1163:9;1150:23;1140:33;;1223:2;1212:9;1208:18;1195:32;1236:31;1261:5;1236:31;:::i;:::-;1286:5;1276:15;;;1059:238;;;;;:::o;1302:258::-;1370:6;1378;1431:2;1419:9;1410:7;1406:23;1402:32;1399:2;;;1452:6;1444;1437:22;1399:2;-1:-1:-1;;1480:23:1;;;1550:2;1535:18;;;1522:32;;-1:-1:-1;1389:171:1:o;1565:567::-;1683:6;1691;1699;1707;1760:3;1748:9;1739:7;1735:23;1731:33;1728:2;;;1782:6;1774;1767:22;1728:2;1823:9;1810:23;1800:33;;1880:2;1869:9;1865:18;1852:32;1842:42;;1934:2;1923:9;1919:18;1906:32;1947:31;1972:5;1947:31;:::i;:::-;1997:5;-1:-1:-1;2054:2:1;2039:18;;2026:32;2067:33;2026:32;2067:33;:::i;:::-;1718:414;;;;-1:-1:-1;1718:414:1;;-1:-1:-1;;1718:414:1:o;2137:274::-;2266:3;2304:6;2298:13;2320:53;2366:6;2361:3;2354:4;2346:6;2342:17;2320:53;:::i;:::-;2389:16;;;;;2274:137;-1:-1:-1;;2274:137:1:o;4717:383::-;4866:2;4855:9;4848:21;4829:4;4898:6;4892:13;4941:6;4936:2;4925:9;4921:18;4914:34;4957:66;5016:6;5011:2;5000:9;4996:18;4991:2;4983:6;4979:15;4957:66;:::i;:::-;5084:2;5063:15;-1:-1:-1;;5059:29:1;5044:45;;;;5091:2;5040:54;;4838:262;-1:-1:-1;;4838:262:1:o;6962:356::-;7164:2;7146:21;;;7183:18;;;7176:30;7242:34;7237:2;7222:18;;7215:62;7309:2;7294:18;;7136:182::o;9591:128::-;9631:3;9662:1;9658:6;9655:1;9652:13;9649:2;;;9668:18;;:::i;:::-;-1:-1:-1;9704:9:1;;9639:80::o;9724:217::-;9764:1;9790;9780:2;;-1:-1:-1;;;9815:31:1;;9869:4;9866:1;9859:15;9897:4;9822:1;9887:15;9780:2;-1:-1:-1;9926:9:1;;9770:171::o;9946:168::-;9986:7;10052:1;10048;10044:6;10040:14;10037:1;10034:21;10029:1;10022:9;10015:17;10011:45;10008:2;;;10059:18;;:::i;:::-;-1:-1:-1;10099:9:1;;9998:116::o;10119:125::-;10159:4;10187:1;10184;10181:8;10178:2;;;10192:18;;:::i;:::-;-1:-1:-1;10229:9:1;;10168:76::o;10249:258::-;10321:1;10331:113;10345:6;10342:1;10339:13;10331:113;;;10421:11;;;10415:18;10402:11;;;10395:39;10367:2;10360:10;10331:113;;;10462:6;10459:1;10456:13;10453:2;;;-1:-1:-1;;10497:1:1;10479:16;;10472:27;10302:205::o;10512:135::-;10551:3;-1:-1:-1;;10572:17:1;;10569:2;;;10592:18;;:::i;:::-;-1:-1:-1;10639:1:1;10628:13;;10559:88::o;10652:127::-;10713:10;10708:3;10704:20;10701:1;10694:31;10744:4;10741:1;10734:15;10768:4;10765:1;10758:15;10784:131;-1:-1:-1;;;;;10859:31:1;;10849:42;;10839:2;;10905:1;10902;10895:12
Swarm Source
ipfs://fd5d0e573d43e93874491acb6c12fd57338bba3fdb80a43d846d06585652fed7
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.