Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 75 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Deposit | 19273695 | 135 days ago | IN | 0 ETH | 0.00213291 | ||||
Emergency Withdr... | 19273693 | 135 days ago | IN | 0 ETH | 0.011757 | ||||
Withdraw | 19242368 | 139 days ago | IN | 0 ETH | 0.00132915 | ||||
Emergency Withdr... | 19242366 | 139 days ago | IN | 0 ETH | 0.00960346 | ||||
Deposit | 19242355 | 139 days ago | IN | 0 ETH | 0.00112275 | ||||
Deposit | 19242347 | 139 days ago | IN | 0 ETH | 0.00072493 | ||||
Emergency Withdr... | 19239100 | 140 days ago | IN | 0 ETH | 0.00269705 | ||||
Emergency Withdr... | 19238785 | 140 days ago | IN | 0 ETH | 0.00442044 | ||||
Withdraw | 19238360 | 140 days ago | IN | 0 ETH | 0.00086452 | ||||
Emergency Withdr... | 19238357 | 140 days ago | IN | 0 ETH | 0.00759761 | ||||
Emergency Withdr... | 19237806 | 140 days ago | IN | 0 ETH | 0.00315941 | ||||
Emergency Withdr... | 19236205 | 140 days ago | IN | 0 ETH | 0.01444949 | ||||
Emergency Withdr... | 19236049 | 140 days ago | IN | 0 ETH | 0.00805638 | ||||
Withdraw | 19235785 | 140 days ago | IN | 0 ETH | 0.00164297 | ||||
Emergency Withdr... | 19235785 | 140 days ago | IN | 0 ETH | 0.00190225 | ||||
Emergency Withdr... | 19235783 | 140 days ago | IN | 0 ETH | 0.014579 | ||||
Emergency Withdr... | 19235481 | 140 days ago | IN | 0 ETH | 0.02188033 | ||||
Deposit | 19234987 | 140 days ago | IN | 0 ETH | 0.00311941 | ||||
Emergency Withdr... | 19234981 | 140 days ago | IN | 0 ETH | 0.01383187 | ||||
Withdraw | 19234613 | 140 days ago | IN | 0 ETH | 0.00196701 | ||||
Emergency Withdr... | 19234613 | 140 days ago | IN | 0 ETH | 0.00227743 | ||||
Emergency Withdr... | 19234612 | 140 days ago | IN | 0 ETH | 0.00548968 | ||||
Emergency Reward... | 19234592 | 140 days ago | IN | 0 ETH | 0.00219061 | ||||
Emergency Reward... | 19234587 | 140 days ago | IN | 0 ETH | 0.00220279 | ||||
Update Lock Dura... | 19234586 | 140 days ago | IN | 0 ETH | 0.00094398 |
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
19218102 | 142 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Contract Name:
CucumberStaking
Compiler Version
v0.8.14+commit.80d49f37
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-02-13 */ /* */ pragma solidity ^0.8.0; // SPDX-License-Identifier: MIT abstract contract Ownable { event OwnershipTransferred(address indexed user, address indexed newOwner); error Unauthorized(); error InvalidOwner(); address public owner; modifier onlyOwner() virtual { if (msg.sender != owner) revert Unauthorized(); _; } constructor(address _owner) { if (_owner == address(0)) revert InvalidOwner(); owner = _owner; emit OwnershipTransferred(address(0), _owner); } function transferOwnership(address _owner) public virtual onlyOwner { if (_owner == address(0)) revert InvalidOwner(); owner = _owner; emit OwnershipTransferred(msg.sender, _owner); } function revokeOwnership() public virtual onlyOwner { owner = address(0); emit OwnershipTransferred(msg.sender, address(0)); } } abstract contract ERC721Receiver { function onERC721Received( address, address, uint256, bytes calldata ) external virtual returns (bytes4) { return ERC721Receiver.onERC721Received.selector; } } abstract contract ERC404 is Ownable { // Events event ERC20Transfer( address indexed from, address indexed to, uint256 amount ); event Approval( address indexed owner, address indexed spender, uint256 amount ); event Transfer( address indexed from, address indexed to, uint256 indexed id ); event ERC721Approval( address indexed owner, address indexed spender, uint256 indexed id ); event ApprovalForAll( address indexed owner, address indexed operator, bool approved ); // Errors error NotFound(); error AlreadyExists(); error InvalidRecipient(); error InvalidSender(); error UnsafeRecipient(); // Metadata /// @dev Token name string public name; /// @dev Token symbol string public symbol; /// @dev Decimals for fractional representation uint8 public immutable decimals; /// @dev Total supply in fractionalized representation uint256 public immutable totalSupply; // @ERC404+ Array of burnt IDs uint256[] public _burnedTokenIds; /// @dev Current mint counter, monotonically increasing to ensure accurate ownership uint256 public minted; /// @dev Current mint counter, monotonically increasing to ensure accurate ownership uint256 public max_mint; // Mappings /// @dev Balance of user in fractional representation mapping(address => uint256) public balanceOf; /// @dev Allowance of user in fractional representation mapping(address => mapping(address => uint256)) public allowance; /// @dev Approval in native representaion mapping(uint256 => address) public getApproved; /// @dev Approval for all in native representation mapping(address => mapping(address => bool)) public isApprovedForAll; /// @dev Owner of id in native representation mapping(uint256 => address) internal _ownerOf; /// @dev Array of owned ids in native representation mapping(address => uint256[]) internal _owned; /// @dev Tracks indices for the _owned mapping mapping(uint256 => uint256) internal _ownedIndex; /// @dev Addresses whitelisted from minting / burning for gas savings (pairs, routers, etc) mapping(address => bool) public whitelist; // Constructor constructor( string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalNativeSupply, address _owner ) Ownable(_owner) { name = _name; max_mint = _totalNativeSupply; symbol = _symbol; decimals = _decimals; totalSupply = _totalNativeSupply * (10 ** decimals); whitelist[msg.sender]=true; } /// @notice Initialization function to set pairs / etc /// saving gas by avoiding mint / burn on unnecessary targets function setWhitelist(address target, bool state) public onlyOwner { whitelist[target] = state; } /// @notice Function to find owner of a given native token function ownerOf(uint256 id) public view virtual returns (address owner) { owner = _ownerOf[id]; if (owner == address(0)) { revert NotFound(); } } /// @notice tokenURI must be implemented by child contract function tokenURI(uint256 id) public view virtual returns (string memory); /// @notice Function for token approvals /// @dev This function assumes id / native if amount less than or equal to current max id function approve( address spender, uint256 amountOrId ) public virtual returns (bool) { if (amountOrId <= minted && amountOrId > 0) { address owner = _ownerOf[amountOrId]; if (msg.sender != owner && !isApprovedForAll[owner][msg.sender]) { revert Unauthorized(); } getApproved[amountOrId] = spender; emit Approval(owner, spender, amountOrId); } else { allowance[msg.sender][spender] = amountOrId; emit Approval(msg.sender, spender, amountOrId); } return true; } /// @notice Function native approvals function setApprovalForAll(address operator, bool approved) public virtual { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } /// @notice Function for mixed transfers /// @dev This function assumes id / native if amount less than or equal to current max id function transferFrom( address from, address to, uint256 amountOrId ) public virtual { if (amountOrId <= minted) { if (from != _ownerOf[amountOrId]) { revert InvalidSender(); } if (to == address(0)) { revert InvalidRecipient(); } if ( msg.sender != from && !isApprovedForAll[from][msg.sender] && msg.sender != getApproved[amountOrId] ) { revert Unauthorized(); } balanceOf[from] -= _getUnit(); unchecked { balanceOf[to] += _getUnit(); } _ownerOf[amountOrId] = to; delete getApproved[amountOrId]; // update _owned for sender uint256 updatedId = _owned[from][_owned[from].length - 1]; _owned[from][_ownedIndex[amountOrId]] = updatedId; // pop _owned[from].pop(); // update index for the moved id _ownedIndex[updatedId] = _ownedIndex[amountOrId]; // push token to to owned _owned[to].push(amountOrId); // update index for to owned _ownedIndex[amountOrId] = _owned[to].length - 1; emit Transfer(from, to, amountOrId); emit ERC20Transfer(from, to, _getUnit()); } else { uint256 allowed = allowance[from][msg.sender]; if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amountOrId; _transfer(from, to, amountOrId); } } /// @notice Function for fractional transfers function transfer( address to, uint256 amount ) public virtual returns (bool) { return _transfer(msg.sender, to, amount); } /// @notice Function for native transfers with contract support function safeTransferFrom( address from, address to, uint256 id ) public virtual { transferFrom(from, to, id); if ( to.code.length != 0 && ERC721Receiver(to).onERC721Received(msg.sender, from, id, "") != ERC721Receiver.onERC721Received.selector ) { revert UnsafeRecipient(); } } /// @notice Function for native transfers with contract support and callback data function safeTransferFrom( address from, address to, uint256 id, bytes calldata data ) public virtual { transferFrom(from, to, id); if ( to.code.length != 0 && ERC721Receiver(to).onERC721Received(msg.sender, from, id, data) != ERC721Receiver.onERC721Received.selector ) { revert UnsafeRecipient(); } } /// @notice Internal function for fractional transfers function _transfer( address from, address to, uint256 amount ) internal returns (bool) { uint256 unit = _getUnit(); uint256 balanceBeforeSender = balanceOf[from]; uint256 balanceBeforeReceiver = balanceOf[to]; balanceOf[from] -= amount; unchecked { balanceOf[to] += amount; } // Skip burn for certain addresses to save gas if (!whitelist[from]) { uint256 tokens_to_burn = (balanceBeforeSender / unit) - (balanceOf[from] / unit); for (uint256 i = 0; i < tokens_to_burn; i++) { _burn(from); } } // Skip minting for certain addresses to save gas if (!whitelist[to]) { uint256 tokens_to_mint = (balanceOf[to] / unit) - (balanceBeforeReceiver / unit); for (uint256 i = 0; i < tokens_to_mint; i++) { _mint(to); } } emit ERC20Transfer(from, to, amount); return true; } // Internal utility logic function _getUnit() internal view returns (uint256) { return 10 ** decimals; } function _mint(address to) internal virtual { if (to == address(0)) { revert InvalidRecipient(); } unchecked { minted++; } uint256 id = minted; if(minted > max_mint && _burnedTokenIds.length > 0){ uint256 lastIndex = _burnedTokenIds.length - 1; id = _burnedTokenIds[lastIndex]; _burnedTokenIds.pop(); } if (_ownerOf[id] != address(0)) { revert AlreadyExists(); } _ownerOf[id] = to; _owned[to].push(id); _ownedIndex[id] = _owned[to].length - 1; emit Transfer(address(0), to, id); } function _burn(address from) internal virtual { if (from == address(0)) { revert InvalidSender(); } uint256 id = _owned[from][_owned[from].length - 1]; _owned[from].pop(); delete _ownedIndex[id]; delete _ownerOf[id]; delete getApproved[id]; // push ID inside of burnt array _burnedTokenIds.push(id); emit Transfer(from, address(0), id); } function _setNameSymbol( string memory _name, string memory _symbol ) internal { name = _name; symbol = _symbol; } } library Math { /** * @dev Muldiv operation overflow. */ error MathOverflowedMulDiv(); enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an overflow flag. */ 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 subtraction of two unsigned integers, with an overflow flag. */ 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. */ 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. */ 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. */ 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 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 towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. return a / b; } // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also // works in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } } /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } /** * @dev String operations. */ library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), HEX_DIGITS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_DIGITS[localValue & 0xf]; localValue >>= 4; } if (localValue != 0) { revert StringsInsufficientHexLength(value, length); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b)); } } interface IUniswapV3Router { function factory() external view returns (address); } interface IUniswapV3Factory { function createPool( address tokenA, address tokenB, uint24 fee ) external returns (address pool); } library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, 'SafeMath: addition overflow'); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, 'SafeMath: subtraction overflow'); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @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) { // 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 0; } uint256 c = a * b; require(c / a == b, 'SafeMath: multiplication overflow'); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, 'SafeMath: division by zero'); } /** * @dev Returns the integer division of two unsigned integers. Reverts 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) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts 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 mod(a, b, 'SafeMath: modulo by zero'); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message 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, string memory errorMessage ) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } function min(uint256 x, uint256 y) internal pure returns (uint256 z) { z = x < y ? x : y; } // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method) function sqrt(uint256 y) internal pure returns (uint256 z) { if (y > 3) { z = y; uint256 x = y / 2 + 1; while (x < z) { z = x; x = (y / x + x) / 2; } } else if (y != 0) { z = 1; } } } interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the ERC token owner. */ function getOwner() external view returns (address); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address _owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeERC20 { using SafeMath for uint256; 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' // solhint-disable-next-line max-line-length 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).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).sub( value, 'SafeERC20: decreased allowance below zero' ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(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 // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed'); } } } /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, 'Address: insufficient balance'); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{value: amount}(''); require(success, 'Address: unable to send value, recipient may have reverted'); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, 'Address: low-level call failed'); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, 'Address: low-level call with value failed'); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, 'Address: insufficient balance for call'); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue( address target, bytes memory data, uint256 weiValue, string memory errorMessage ) private returns (bytes memory) { require(isContract(target), 'Address: call to non-contract'); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value: weiValue}(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } contract CucumberStaking is Ownable, ReentrancyGuard { 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. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 lastRewardTimestamp; // Last block number that Tokens distribution occurs. uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below. } IERC20 public immutable stakingToken; IERC20 public immutable rewardToken; mapping (address => uint256) public holderUnlockTime; uint256 public totalStaked; uint256 public apr; uint256 public lockDuration; uint256 public exitPenaltyPerc; bool public canCompoundOrStakeMore; // Info of each pool. PoolInfo public poolInfo; // Info of each user that stakes LP tokens. mapping (address => UserInfo) public userInfo; event Deposit(address indexed user, uint256 amount); event Withdraw(address indexed user, uint256 amount); event Compound(address indexed user); event EmergencyWithdraw(address indexed user, uint256 amount); constructor(address _stakingToken, address _rewardToken, uint256 _apr, uint256 _lockDurationInDays, uint256 _exitPenaltyPerc, bool _canCompoundOrStakeMore, address _owner) Ownable(_owner){ stakingToken = IERC20(_stakingToken); rewardToken = IERC20(_rewardToken); canCompoundOrStakeMore = _canCompoundOrStakeMore; apr = _apr; lockDuration = _lockDurationInDays * 1 days; exitPenaltyPerc = _exitPenaltyPerc; // staking pool poolInfo = (PoolInfo({ lpToken: stakingToken, lastRewardTimestamp: 99999999999, accTokensPerShare: 0 })); } function stopReward() external onlyOwner { updatePool(); apr = 0; } function startReward() external onlyOwner { require(poolInfo.lastRewardTimestamp == 99999999999, "Can only start rewards once"); poolInfo.lastRewardTimestamp = block.timestamp; } // View function to see pending Reward on frontend. function pendingReward(address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo; UserInfo storage user = userInfo[_user]; if(pool.lastRewardTimestamp == 99999999999){ return 0; } uint256 accTokensPerShare = pool.accTokensPerShare; uint256 lpSupply = totalStaked; if (block.timestamp > pool.lastRewardTimestamp && lpSupply != 0) { uint256 tokenReward = calculateNewRewards(); accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt); } // Update reward variables of the given pool to be up-to-date. function updatePool() internal { PoolInfo storage pool = poolInfo; if (block.timestamp <= pool.lastRewardTimestamp) { return; } uint256 lpSupply = totalStaked; if (lpSupply == 0) { pool.lastRewardTimestamp = block.timestamp; return; } uint256 tokenReward = calculateNewRewards(); pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply)); pool.lastRewardTimestamp = block.timestamp; } // Stake primary tokens function deposit(uint256 _amount) external nonReentrant { if(holderUnlockTime[msg.sender] == 0){ holderUnlockTime[msg.sender] = block.timestamp + lockDuration; } PoolInfo storage pool = poolInfo; UserInfo storage user = userInfo[msg.sender]; if(!canCompoundOrStakeMore && _amount > 0){ require(user.amount == 0, "Cannot stake more"); } updatePool(); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { require(pending <= rewardsRemaining(), "Cannot withdraw other people's staked tokens. Contact an admin."); rewardToken.safeTransfer(address(msg.sender), pending); } } uint256 amountTransferred = 0; if(_amount > 0) { uint256 initialBalance = pool.lpToken.balanceOf(address(this)); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); amountTransferred = pool.lpToken.balanceOf(address(this)) - initialBalance; user.amount = user.amount.add(amountTransferred); totalStaked += amountTransferred; } user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12); emit Deposit(msg.sender, _amount); } function compound() external nonReentrant { require(canCompoundOrStakeMore, "Cannot compound"); PoolInfo storage pool = poolInfo; UserInfo storage user = userInfo[msg.sender]; updatePool(); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { require(pending <= rewardsRemaining(), "Cannot withdraw other people's staked tokens. Contact an admin."); user.amount += pending; totalStaked += pending; } } user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12); emit Compound(msg.sender); } // Withdraw primary tokens from STAKING. function withdraw() external nonReentrant { require(holderUnlockTime[msg.sender] <= block.timestamp, "May not do normal withdraw early"); PoolInfo storage pool = poolInfo; UserInfo storage user = userInfo[msg.sender]; uint256 _amount = user.amount; updatePool(); uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0){ require(pending <= rewardsRemaining(), "Cannot withdraw other people's staked tokens. Contact an admin."); rewardToken.safeTransfer(address(msg.sender), pending); } if(_amount > 0) { user.amount = 0; totalStaked -= _amount; pool.lpToken.safeTransfer(address(msg.sender), _amount); } user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12); if(user.amount > 0){ holderUnlockTime[msg.sender] = block.timestamp + lockDuration; } else { holderUnlockTime[msg.sender] = 0; } emit Withdraw(msg.sender, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw() external nonReentrant { PoolInfo storage pool = poolInfo; UserInfo storage user = userInfo[msg.sender]; uint256 _amount = user.amount; totalStaked -= _amount; // exit penalty for early unstakers, penalty held on contract as rewards. if(holderUnlockTime[msg.sender] >= block.timestamp){ _amount -= _amount * exitPenaltyPerc / 100; } holderUnlockTime[msg.sender] = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); user.amount = 0; user.rewardDebt = 0; emit EmergencyWithdraw(msg.sender, _amount); } // Withdraw reward. EMERGENCY ONLY. This allows the owner to migrate rewards to a new staking pool since we are not minting new tokens. function emergencyRewardWithdraw(uint256 _amount) external onlyOwner { require(_amount <= rewardToken.balanceOf(address(this)) - totalStaked, 'not enough tokens to take out'); rewardToken.safeTransfer(address(msg.sender), _amount); } function calculateNewRewards() public view returns (uint256) { PoolInfo storage pool = poolInfo; if(pool.lastRewardTimestamp > block.timestamp){ return 0; } return (((block.timestamp - pool.lastRewardTimestamp) * totalStaked) * apr / 100 / 365 days); } function rewardsRemaining() public view returns (uint256){ if(rewardToken == stakingToken){ return rewardToken.balanceOf(address(this)) - totalStaked; } else { return rewardToken.balanceOf(address(this)); } } function updateApr(uint256 newApr) external onlyOwner { require(newApr <= 10000, "APR must be below 10000%"); updatePool(); apr = newApr; } function updateExitPenalty(uint256 newPenaltyPerc) external onlyOwner { require(newPenaltyPerc <= 20, "May not set higher than 20%"); exitPenaltyPerc = newPenaltyPerc; } function updateLockDuration(uint256 daysForLock) external onlyOwner { require(daysForLock <= 30, "Lock must be 30 days or less."); lockDuration = daysForLock * 1 days; } function updateCanCompoundOrStakeMore(bool compoundEnabled) external onlyOwner { canCompoundOrStakeMore = compoundEnabled; } } contract Cucumbers404 is ERC404 { IUniswapV3Router public immutable v3Router; address public pool; string public baseTokenURI; CucumberStaking public cucumberStakingContract; constructor( address _owner, uint256 _supply ) ERC404("Cucumber Finance", "CUCF", 18, _supply, _owner) { address wethContract; address _v3Router; // @dev assumes WETH pair if(block.chainid == 1){ wethContract = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; _v3Router = 0xE592427A0AEce92De3Edee1F18E0157C05861564; } else if(block.chainid == 5){ wethContract = 0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6; _v3Router = 0xE592427A0AEce92De3Edee1F18E0157C05861564; } else { revert("Chain not configured"); } v3Router = IUniswapV3Router(_v3Router); pool = IUniswapV3Factory(v3Router.factory()).createPool(address(this), wethContract, 10000); cucumberStakingContract = new CucumberStaking(address(this), address(this), 5000, 3, 20, true, _owner); whitelist[address(v3Router)] = true; whitelist[pool] = true; whitelist[_owner] = true; whitelist[address(cucumberStakingContract)] = true; balanceOf[_owner] = _supply * _getUnit(); } function setTokenURI(string memory _tokenURI) public onlyOwner { baseTokenURI = _tokenURI; } function tokenURI(uint256 id) public view override returns (string memory) { return string.concat(baseTokenURI, Strings.toString(id)); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_stakingToken","type":"address"},{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_apr","type":"uint256"},{"internalType":"uint256","name":"_lockDurationInDays","type":"uint256"},{"internalType":"uint256","name":"_exitPenaltyPerc","type":"uint256"},{"internalType":"bool","name":"_canCompoundOrStakeMore","type":"bool"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidOwner","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Compound","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","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":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"apr","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateNewRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canCompoundOrStakeMore","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"compound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emergencyRewardWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exitPenaltyPerc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"holderUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockDuration","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":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"accTokensPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revokeOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newApr","type":"uint256"}],"name":"updateApr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"compoundEnabled","type":"bool"}],"name":"updateCanCompoundOrStakeMore","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPenaltyPerc","type":"uint256"}],"name":"updateExitPenalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"daysForLock","type":"uint256"}],"name":"updateLockDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"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":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
60c06040523480156200001157600080fd5b506040516200374238038062003742833981810160405281019062000037919062000371565b80600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16036200009f576040517f49e27cff00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350600180819055508673ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff16815250508573ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff168152505081600760006101000a81548160ff021916908315150217905550846004819055506201518084620001dc919062000453565b60058190555082600681905550604051806060016040528060805173ffffffffffffffffffffffffffffffffffffffff16815260200164174876e7ff81526020016000815250600860008201518160000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602082015181600101556040820151816002015590505050505050505050620004b4565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000620002c18262000294565b9050919050565b620002d381620002b4565b8114620002df57600080fd5b50565b600081519050620002f381620002c8565b92915050565b6000819050919050565b6200030e81620002f9565b81146200031a57600080fd5b50565b6000815190506200032e8162000303565b92915050565b60008115159050919050565b6200034b8162000334565b81146200035757600080fd5b50565b6000815190506200036b8162000340565b92915050565b600080600080600080600060e0888a0312156200039357620003926200028f565b5b6000620003a38a828b01620002e2565b9750506020620003b68a828b01620002e2565b9650506040620003c98a828b016200031d565b9550506060620003dc8a828b016200031d565b9450506080620003ef8a828b016200031d565b93505060a0620004028a828b016200035a565b92505060c0620004158a828b01620002e2565b91505092959891949750929550565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60006200046082620002f9565b91506200046d83620002f9565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615620004a957620004a862000424565b5b828202905092915050565b60805160a0516132306200051260003960008181610704015281816107ef01528181610a0501528181610d9101528181610dd001528181610e7b015281816114640152611f37015260008181610c570152610d5a01526132306000f3fe608060405234801561001057600080fd5b50600436106101a95760003560e01c806380dc0672116100f9578063b6b55f2511610097578063f2fde38b11610071578063f2fde38b14610417578063f40f0f5214610433578063f69e204614610463578063f7c618c11461046d576101a9565b8063b6b55f25146103d5578063d477edf4146103f1578063db2e21bc1461040d576101a9565b80638da5cb5b116100d35780638da5cb5b1461034d5780638e0b01981461036b578063999e2f7514610387578063a913a5f7146103a5576101a9565b806380dc067214610309578063817b1cd2146103135780638552bf9014610331576101a9565b806357ded9c91161016657806372f702f31161014057806372f702f3146102a5578063746c8ae1146102c357806378c196f3146102cd5780637b280def146102eb576101a9565b806357ded9c9146102495780635a2f3d091461026757806368365d0314610287576101a9565b806304554443146101ae5780630698260f146101cc5780631959a002146101e85780632b968958146102195780633279beab146102235780633ccfd60b1461023f575b600080fd5b6101b661048b565b6040516101c39190612599565b60405180910390f35b6101e660048036038101906101e191906125f1565b610491565b005b61020260048036038101906101fd919061267c565b610533565b6040516102109291906126a9565b60405180910390f35b610221610557565b005b61023d600480360381019061023891906126fe565b61067a565b005b610247610836565b005b610251610c04565b60405161025e9190612599565b60405180910390f35b61026f610c0a565b60405161027e9392919061278a565b60405180910390f35b61028f610c42565b60405161029c91906127d0565b60405180910390f35b6102ad610c55565b6040516102ba91906127eb565b60405180910390f35b6102cb610c79565b005b6102d5610d56565b6040516102e29190612599565b60405180910390f35b6102f3610f19565b6040516103009190612599565b60405180910390f35b610311610f1f565b005b61031b610fb6565b6040516103289190612599565b60405180910390f35b61034b600480360381019061034691906126fe565b610fbc565b005b610355611098565b6040516103629190612815565b60405180910390f35b610385600480360381019061038091906126fe565b6110bc565b005b61038f61118f565b60405161039c9190612599565b60405180910390f35b6103bf60048036038101906103ba919061267c565b6111f8565b6040516103cc9190612599565b60405180910390f35b6103ef60048036038101906103ea91906126fe565b611210565b005b61040b600480360381019061040691906126fe565b611722565b005b610415611803565b005b610431600480360381019061042c919061267c565b611a2b565b005b61044d6004803603810190610448919061267c565b611bb3565b60405161045a9190612599565b60405180910390f35b61046b611cdd565b005b610475611f35565b60405161048291906127eb565b60405180910390f35b60055481565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610516576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600760006101000a81548160ff02191690831515021790555050565b600b6020528060005260406000206000915090508060000154908060010154905082565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146105dc576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146106ff576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003547f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161075b9190612815565b602060405180830381865afa158015610778573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061079c9190612845565b6107a691906128a1565b8111156107e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107df90612932565b60405180910390fd5b61083333827f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16611f599092919063ffffffff16565b50565b60026001540361087b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108729061299e565b60405180910390fd5b600260018190555042600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020541115610905576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108fc90612a0a565b60405180910390fd5b6000600890506000600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000154905061095f611fdf565b60006109a9836001015461099b64e8d4a5100061098d8860020154886000015461207890919063ffffffff16565b6120f290919063ffffffff16565b61213c90919063ffffffff16565b90506000811115610a4a576109bc610d56565b8111156109fe576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109f590612a9c565b60405180910390fd5b610a4933827f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16611f599092919063ffffffff16565b5b6000821115610ac657600083600001819055508160036000828254610a6f91906128a1565b92505081905550610ac533838660000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611f599092919063ffffffff16565b5b610af864e8d4a51000610aea8660020154866000015461207890919063ffffffff16565b6120f290919063ffffffff16565b8360010181905550600083600001541115610b635760055442610b1b9190612abc565b600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610ba9565b6000600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b3373ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a942436483604051610bef9190612599565b60405180910390a25050505060018081905550565b60045481565b60088060000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010154908060020154905083565b600760009054906101000a900460ff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610cfe576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b64174876e7ff60086001015414610d4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d4190612b5e565b60405180910390fd5b42600860010181905550565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff167f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1603610e79576003547f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610e279190612815565b602060405180830381865afa158015610e44573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e689190612845565b610e7291906128a1565b9050610f16565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610ed29190612815565b602060405180830381865afa158015610eef573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f139190612845565b90505b90565b60065481565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610fa4576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610fac611fdf565b6000600481905550565b60035481565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611041576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b612710811115611086576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161107d90612bca565b60405180910390fd5b61108e611fdf565b8060048190555050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611141576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6014811115611185576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161117c90612c36565b60405180910390fd5b8060068190555050565b6000806008905042816001015411156111ac5760009150506111f5565b6301e1338060646004546003548460010154426111c991906128a1565b6111d39190612c56565b6111dd9190612c56565b6111e79190612cdf565b6111f19190612cdf565b9150505b90565b60026020528060005260406000206000915090505481565b600260015403611255576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161124c9061299e565b60405180910390fd5b60026001819055506000600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054036112f657600554426112b29190612abc565b600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b6000600890506000600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050600760009054906101000a900460ff1615801561135c5750600083115b156113a95760008160000154146113a8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161139f90612d5c565b60405180910390fd5b5b6113b1611fdf565b6000816000015411156114ab57600061140882600101546113fa64e8d4a510006113ec8760020154876000015461207890919063ffffffff16565b6120f290919063ffffffff16565b61213c90919063ffffffff16565b905060008111156114a95761141b610d56565b81111561145d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161145490612a9c565b60405180910390fd5b6114a833827f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16611f599092919063ffffffff16565b5b505b60008084111561168d5760008360000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016115149190612815565b602060405180830381865afa158015611531573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115559190612845565b90506115a83330878760000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612186909392919063ffffffff16565b808460000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016116069190612815565b602060405180830381865afa158015611623573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116479190612845565b61165191906128a1565b915061166a82846000015461220f90919063ffffffff16565b836000018190555081600360008282546116849190612abc565b92505081905550505b6116bf64e8d4a510006116b18560020154856000015461207890919063ffffffff16565b6120f290919063ffffffff16565b82600101819055503373ffffffffffffffffffffffffffffffffffffffff167fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c8560405161170d9190612599565b60405180910390a25050506001808190555050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146117a7576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b601e8111156117eb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117e290612dc8565b60405180910390fd5b62015180816117fa9190612c56565b60058190555050565b600260015403611848576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161183f9061299e565b60405180910390fd5b60026001819055506000600890506000600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000154905080600360008282546118b491906128a1565b9250508190555042600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205410611929576064600654826119119190612c56565b61191b9190612cdf565b8161192691906128a1565b90505b6000600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506119bd33828560000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611f599092919063ffffffff16565b60008260000181905550600082600101819055503373ffffffffffffffffffffffffffffffffffffffff167f5fafa99d0643513820be26656b45130b01e1c03062e1266bf36f88cbd3bd969582604051611a179190612599565b60405180910390a250505060018081905550565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611ab0576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603611b16576040517f49e27cff00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350565b600080600890506000600b60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905064174876e7ff826001015403611c1857600092505050611cd8565b60008260020154905060006003549050836001015442118015611c3c575060008114155b15611c8d576000611c4b61118f565b9050611c89611c7a83611c6c64e8d4a510008561207890919063ffffffff16565b6120f290919063ffffffff16565b8461220f90919063ffffffff16565b9250505b611cd18360010154611cc364e8d4a51000611cb586886000015461207890919063ffffffff16565b6120f290919063ffffffff16565b61213c90919063ffffffff16565b9450505050505b919050565b600260015403611d22576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d199061299e565b60405180910390fd5b6002600181905550600760009054906101000a900460ff16611d79576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d7090612e34565b60405180910390fd5b6000600890506000600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050611dca611fdf565b600081600001541115611ead576000611e218260010154611e1364e8d4a51000611e058760020154876000015461207890919063ffffffff16565b6120f290919063ffffffff16565b61213c90919063ffffffff16565b90506000811115611eab57611e34610d56565b811115611e76576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e6d90612a9c565b60405180910390fd5b80826000016000828254611e8a9190612abc565b925050819055508060036000828254611ea39190612abc565b925050819055505b505b611edf64e8d4a51000611ed18460020154846000015461207890919063ffffffff16565b6120f290919063ffffffff16565b81600101819055503373ffffffffffffffffffffffffffffffffffffffff167fda323bd96658b18a6ce813e824305dc61760462bad6aaf52c65aebb8c8c9faa160405160405180910390a2505060018081905550565b7f000000000000000000000000000000000000000000000000000000000000000081565b611fda8363a9059cbb60e01b8484604051602401611f78929190612e54565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505061226d565b505050565b60006008905080600101544211611ff65750612076565b6000600354905060008103612015574282600101819055505050612076565b600061201f61118f565b905061206161204e8361204064e8d4a510008561207890919063ffffffff16565b6120f290919063ffffffff16565b846002015461220f90919063ffffffff16565b83600201819055504283600101819055505050505b565b600080830361208a57600090506120ec565b600082846120989190612c56565b90508284826120a79190612cdf565b146120e7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120de90612eef565b60405180910390fd5b809150505b92915050565b600061213483836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612334565b905092915050565b600061217e83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612397565b905092915050565b612209846323b872dd60e01b8585856040516024016121a793929190612f0f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505061226d565b50505050565b600080828461221e9190612abc565b905083811015612263576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161225a90612f92565b60405180910390fd5b8091505092915050565b60006122cf826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166123fb9092919063ffffffff16565b905060008151111561232f57808060200190518101906122ef9190612fc7565b61232e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161232590613066565b60405180910390fd5b5b505050565b6000808311829061237b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612372919061310e565b60405180910390fd5b506000838561238a9190612cdf565b9050809150509392505050565b60008383111582906123df576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123d6919061310e565b60405180910390fd5b50600083856123ee91906128a1565b9050809150509392505050565b606061240a8484600085612413565b90509392505050565b606061241e85612535565b61245d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016124549061317c565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161248691906131e3565b60006040518083038185875af1925050503d80600081146124c3576040519150601f19603f3d011682016040523d82523d6000602084013e6124c8565b606091505b509150915081156124dd57809250505061252d565b6000815111156124f05780518082602001fd5b836040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612524919061310e565b60405180910390fd5b949350505050565b60008060007fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060001b9050833f915080821415801561257757506000801b8214155b92505050919050565b6000819050919050565b61259381612580565b82525050565b60006020820190506125ae600083018461258a565b92915050565b600080fd5b60008115159050919050565b6125ce816125b9565b81146125d957600080fd5b50565b6000813590506125eb816125c5565b92915050565b600060208284031215612607576126066125b4565b5b6000612615848285016125dc565b91505092915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60006126498261261e565b9050919050565b6126598161263e565b811461266457600080fd5b50565b60008135905061267681612650565b92915050565b600060208284031215612692576126916125b4565b5b60006126a084828501612667565b91505092915050565b60006040820190506126be600083018561258a565b6126cb602083018461258a565b9392505050565b6126db81612580565b81146126e657600080fd5b50565b6000813590506126f8816126d2565b92915050565b600060208284031215612714576127136125b4565b5b6000612722848285016126e9565b91505092915050565b6000819050919050565b600061275061274b6127468461261e565b61272b565b61261e565b9050919050565b600061276282612735565b9050919050565b600061277482612757565b9050919050565b61278481612769565b82525050565b600060608201905061279f600083018661277b565b6127ac602083018561258a565b6127b9604083018461258a565b949350505050565b6127ca816125b9565b82525050565b60006020820190506127e560008301846127c1565b92915050565b6000602082019050612800600083018461277b565b92915050565b61280f8161263e565b82525050565b600060208201905061282a6000830184612806565b92915050565b60008151905061283f816126d2565b92915050565b60006020828403121561285b5761285a6125b4565b5b600061286984828501612830565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60006128ac82612580565b91506128b783612580565b9250828210156128ca576128c9612872565b5b828203905092915050565b600082825260208201905092915050565b7f6e6f7420656e6f75676820746f6b656e7320746f2074616b65206f7574000000600082015250565b600061291c601d836128d5565b9150612927826128e6565b602082019050919050565b6000602082019050818103600083015261294b8161290f565b9050919050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b6000612988601f836128d5565b915061299382612952565b602082019050919050565b600060208201905081810360008301526129b78161297b565b9050919050565b7f4d6179206e6f7420646f206e6f726d616c207769746864726177206561726c79600082015250565b60006129f46020836128d5565b91506129ff826129be565b602082019050919050565b60006020820190508181036000830152612a23816129e7565b9050919050565b7f43616e6e6f74207769746864726177206f746865722070656f706c652773207360008201527f74616b656420746f6b656e732e2020436f6e7461637420616e2061646d696e2e602082015250565b6000612a866040836128d5565b9150612a9182612a2a565b604082019050919050565b60006020820190508181036000830152612ab581612a79565b9050919050565b6000612ac782612580565b9150612ad283612580565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115612b0757612b06612872565b5b828201905092915050565b7f43616e206f6e6c792073746172742072657761726473206f6e63650000000000600082015250565b6000612b48601b836128d5565b9150612b5382612b12565b602082019050919050565b60006020820190508181036000830152612b7781612b3b565b9050919050565b7f415052206d7573742062652062656c6f77203130303030250000000000000000600082015250565b6000612bb46018836128d5565b9150612bbf82612b7e565b602082019050919050565b60006020820190508181036000830152612be381612ba7565b9050919050565b7f4d6179206e6f742073657420686967686572207468616e203230250000000000600082015250565b6000612c20601b836128d5565b9150612c2b82612bea565b602082019050919050565b60006020820190508181036000830152612c4f81612c13565b9050919050565b6000612c6182612580565b9150612c6c83612580565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615612ca557612ca4612872565b5b828202905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000612cea82612580565b9150612cf583612580565b925082612d0557612d04612cb0565b5b828204905092915050565b7f43616e6e6f74207374616b65206d6f7265000000000000000000000000000000600082015250565b6000612d466011836128d5565b9150612d5182612d10565b602082019050919050565b60006020820190508181036000830152612d7581612d39565b9050919050565b7f4c6f636b206d7573742062652033302064617973206f72206c6573732e000000600082015250565b6000612db2601d836128d5565b9150612dbd82612d7c565b602082019050919050565b60006020820190508181036000830152612de181612da5565b9050919050565b7f43616e6e6f7420636f6d706f756e640000000000000000000000000000000000600082015250565b6000612e1e600f836128d5565b9150612e2982612de8565b602082019050919050565b60006020820190508181036000830152612e4d81612e11565b9050919050565b6000604082019050612e696000830185612806565b612e76602083018461258a565b9392505050565b7f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f60008201527f7700000000000000000000000000000000000000000000000000000000000000602082015250565b6000612ed96021836128d5565b9150612ee482612e7d565b604082019050919050565b60006020820190508181036000830152612f0881612ecc565b9050919050565b6000606082019050612f246000830186612806565b612f316020830185612806565b612f3e604083018461258a565b949350505050565b7f536166654d6174683a206164646974696f6e206f766572666c6f770000000000600082015250565b6000612f7c601b836128d5565b9150612f8782612f46565b602082019050919050565b60006020820190508181036000830152612fab81612f6f565b9050919050565b600081519050612fc1816125c5565b92915050565b600060208284031215612fdd57612fdc6125b4565b5b6000612feb84828501612fb2565b91505092915050565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b6000613050602a836128d5565b915061305b82612ff4565b604082019050919050565b6000602082019050818103600083015261307f81613043565b9050919050565b600081519050919050565b60005b838110156130af578082015181840152602081019050613094565b838111156130be576000848401525b50505050565b6000601f19601f8301169050919050565b60006130e082613086565b6130ea81856128d5565b93506130fa818560208601613091565b613103816130c4565b840191505092915050565b6000602082019050818103600083015261312881846130d5565b905092915050565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b6000613166601d836128d5565b915061317182613130565b602082019050919050565b6000602082019050818103600083015261319581613159565b9050919050565b600081519050919050565b600081905092915050565b60006131bd8261319c565b6131c781856131a7565b93506131d7818560208601613091565b80840191505092915050565b60006131ef82846131b2565b91508190509291505056fea2646970667358221220078aea9a68930801b6356094dda7b694bb34594afc157cb4cc981b3b4654049d64736f6c634300080e0033000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf00000000000000000000000000000000000000000000000000000000000013880000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000010000000000000000000000009637829c0c784dc876fdb49f6b47ca544ae38a62
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf00000000000000000000000000000000000000000000000000000000000013880000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000010000000000000000000000009637829c0c784dc876fdb49f6b47ca544ae38a62
-----Decoded View---------------
Arg [0] : _stakingToken (address): 0xfD09a37a4f45fc60ad4EDb732D3C91eAe02462Cf
Arg [1] : _rewardToken (address): 0xfD09a37a4f45fc60ad4EDb732D3C91eAe02462Cf
Arg [2] : _apr (uint256): 5000
Arg [3] : _lockDurationInDays (uint256): 3
Arg [4] : _exitPenaltyPerc (uint256): 20
Arg [5] : _canCompoundOrStakeMore (bool): True
Arg [6] : _owner (address): 0x9637829C0C784DC876fdb49F6b47cA544ae38A62
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf
Arg [1] : 000000000000000000000000fd09a37a4f45fc60ad4edb732d3c91eae02462cf
Arg [2] : 0000000000000000000000000000000000000000000000000000000000001388
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [6] : 0000000000000000000000009637829c0c784dc876fdb49f6b47ca544ae38a62
Deployed Bytecode Sourcemap
51351:9544:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52196:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60754:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52423:45;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;803:151;;;:::i;:::-;;59323:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57291:1150;;;:::i;:::-;;52171:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52343:24;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;52273:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51992:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53471:201;;;:::i;:::-;;59901:266;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52230:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53373:90;;;:::i;:::-;;52138:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60175:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;244:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60354:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59587:306;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52077:52;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55072:1406;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60554:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58512:662;;;:::i;:::-;;576:219;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53737:682;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56486:749;;;:::i;:::-;;52035:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52196:27;;;;:::o;60754:138::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;60869:15:::1;60844:22;;:40;;;;;;;;;;;;;;;;;;60754:138:::0;:::o;52423:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;803:151::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;882:1:::1;866:5:::0;::::1;:18;;;;;;;;;;;;;;;;;;943:1;902:44;;923:10;902:44;;;;;;;;;;;;803:151::o:0;59323:256::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;59461:11:::1;;59422;:21;;;59452:4;59422:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;;:::i;:::-;59411:7;:61;;59403:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;59517:54;59550:10;59563:7;59517:11;:24;;;;:54;;;;;:::i;:::-;59323:256:::0;:::o;57291:1150::-;50404:1;51002:7;;:19;50994:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50404:1;51135:7;:18;;;;57386:15:::1;57354:16;:28;57371:10;57354:28;;;;;;;;;;;;;;;;:47;;57346:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;57459:21;57483:8;57459:32;;57502:21;57526:8;:20;57535:10;57526:20;;;;;;;;;;;;;;;57502:44;;57559:15;57577:4;:11;;;57559:29;;57599:12;:10;:12::i;:::-;57622:15;57640:70;57694:4;:15;;;57640:49;57684:4;57640:39;57656:4;:22;;;57640:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;57622:88;;57734:1;57724:7;:11;57721:217;;;57770:18;:16;:18::i;:::-;57759:7;:29;;57751:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;57872:54;57905:10;57918:7;57872:11;:24;;;;:54;;;;;:::i;:::-;57721:217;57963:1;57953:7;:11;57950:165;;;57995:1;57981:4;:11;;:15;;;;58026:7;58011:11;;:22;;;;;;;:::i;:::-;;;;;;;;58048:55;58082:10;58095:7;58048:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;57950:165;58145:49;58189:4;58145:39;58161:4;:22;;;58145:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;58127:4;:15;;:67;;;;58232:1;58218:4;:11;;;:15;58215:172;;;58298:12;;58280:15;:30;;;;:::i;:::-;58249:16;:28;58266:10;58249:28;;;;;;;;;;;;;;;:61;;;;58215:172;;;58374:1;58343:16;:28;58360:10;58343:28;;;;;;;;;;;;;;;:32;;;;58215:172;58413:10;58404:29;;;58425:7;58404:29;;;;;;:::i;:::-;;;;;;;;57333:1108;;;;50360:1:::0;51314:7;:22;;;;57291:1150::o;52171:18::-;;;;:::o;52343:24::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;52273:34::-;;;;;;;;;;;;;:::o;51992:36::-;;;:::o;53471:201::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;53564:11:::1;53532:8;:28;;;:43;53524:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;53649:15;53618:8;:28;;:46;;;;53471:201::o:0;59901:266::-;59950:7;59987:12;59972:27;;:11;:27;;;59969:191;;60061:11;;60022;:21;;;60052:4;60022:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;;:::i;:::-;60015:57;;;;59969:191;60112:11;:21;;;60142:4;60112:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60105:43;;59901:266;;:::o;52230:30::-;;;;:::o;53373:90::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;53425:12:::1;:10;:12::i;:::-;53454:1;53448:3;:7;;;;53373:90::o:0;52138:26::-;;;;:::o;60175:171::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;60258:5:::1;60248:6;:15;;60240:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;60303:12;:10;:12::i;:::-;60332:6;60326:3;:12;;;;60175:171:::0;:::o;244:20::-;;;;;;;;;;;;:::o;60354:192::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;60461:2:::1;60443:14;:20;;60435:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;60524:14;60506:15;:32;;;;60354:192:::0;:::o;59587:306::-;59639:7;59659:21;59683:8;59659:32;;59732:15;59705:4;:24;;;:42;59702:81;;;59770:1;59763:8;;;;;59702:81;59876:8;59870:3;59864;;59849:11;;59821:4;:24;;;59803:15;:42;;;;:::i;:::-;59802:58;;;;:::i;:::-;59801:66;;;;:::i;:::-;:72;;;;:::i;:::-;:83;;;;:::i;:::-;59793:92;;;59587:306;;:::o;52077:52::-;;;;;;;;;;;;;;;;;:::o;55072:1406::-;50404:1;51002:7;;:19;50994:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50404:1;51135:7;:18;;;;55174:1:::1;55142:16;:28;55159:10;55142:28;;;;;;;;;;;;;;;;:33:::0;55139:125:::1;;55240:12;;55222:15;:30;;;;:::i;:::-;55191:16;:28;55208:10;55191:28;;;;;;;;;;;;;;;:61;;;;55139:125;55274:21;55298:8;55274:32;;55317:21;55341:8;:20;55350:10;55341:20;;;;;;;;;;;;;;;55317:44;;55378:22;;;;;;;;;;;55377:23;:38;;;;;55414:1;55404:7;:11;55377:38;55374:115;;;55454:1;55439:4;:11;;;:16;55431:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;55374:115;55501:12;:10;:12::i;:::-;55542:1;55528:4;:11;;;:15;55524:380;;;55560:15;55578:70;55632:4;:15;;;55578:49;55622:4;55578:39;55594:4;:22;;;55578:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;55560:88;;55676:1;55666:7;:11;55663:230;;;55717:18;:16;:18::i;:::-;55706:7;:29;;55698:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;55823:54;55856:10;55869:7;55823:11;:24;;;;:54;;;;;:::i;:::-;55663:230;55545:359;55524:380;55914:25;55967:1:::0;55957:7:::1;:11;55954:393;;;55985:22;56010:4;:12;;;;;;;;;;;;:22;;;56041:4;56010:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55985:62;;56062:74;56100:10;56121:4;56128:7;56062:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;56211:14;56171:4;:12;;;;;;;;;;;;:22;;;56202:4;56171:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:54;;;;:::i;:::-;56151:74;;56254:34;56270:17;56254:4;:11;;;:15;;:34;;;;:::i;:::-;56240:4;:11;;:48;;;;56318:17;56303:11;;:32;;;;;;;:::i;:::-;;;;;;;;55970:377;55954:393;56375:49;56419:4;56375:39;56391:4;:22;;;56375:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;56357:4;:15;;:67;;;;56450:10;56442:28;;;56462:7;56442:28;;;;;;:::i;:::-;;;;;;;;55128:1350;;;50360:1:::0;51314:7;:22;;;;55072:1406;:::o;60554:192::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;60656:2:::1;60641:11;:17;;60633:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;60732:6;60718:11;:20;;;;:::i;:::-;60703:12;:35;;;;60554:192:::0;:::o;58512:662::-;50404:1;51002:7;;:19;50994:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50404:1;51135:7;:18;;;;58574:21:::1;58598:8;58574:32;;58617:21;58641:8;:20;58650:10;58641:20;;;;;;;;;;;;;;;58617:44;;58672:15;58690:4;:11;;;58672:29;;58727:7;58712:11;;:22;;;;;;;:::i;:::-;;;;;;;;58863:15;58831:16;:28;58848:10;58831:28;;;;;;;;;;;;;;;;:47;58828:120;;58933:3;58915:15;;58905:7;:25;;;;:::i;:::-;:31;;;;:::i;:::-;58894:42;;;;;:::i;:::-;;;58828:120;58989:1;58958:16;:28;58975:10;58958:28;;;;;;;;;;;;;;;:32;;;;59001:55;59035:10;59048:7;59001:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;59081:1;59067:4;:11;;:15;;;;59111:1;59093:4;:15;;:19;;;;59146:10;59128:38;;;59158:7;59128:38;;;;;;:::i;:::-;;;;;;;;58563:611;;;50360:1:::0;51314:7;:22;;;;58512:662::o;576:219::-;331:5;;;;;;;;;;317:19;;:10;:19;;;313:46;;345:14;;;;;;;;;;;;;;313:46;677:1:::1;659:20;;:6;:20;;::::0;655:47:::1;;688:14;;;;;;;;;;;;;;655:47;723:6;715:5;::::0;:14:::1;;;;;;;;;;;;;;;;;;780:6;747:40;;768:10;747:40;;;;;;;;;;;;576:219:::0;:::o;53737:682::-;53798:7;53818:21;53842:8;53818:32;;53861:21;53885:8;:15;53894:5;53885:15;;;;;;;;;;;;;;;53861:39;;53942:11;53914:4;:24;;;:39;53911:78;;53976:1;53969:8;;;;;;53911:78;53999:25;54027:4;:22;;;53999:50;;54060:16;54079:11;;54060:30;;54123:4;:24;;;54105:15;:42;:59;;;;;54163:1;54151:8;:13;;54105:59;54101:228;;;54181:19;54203:21;:19;:21::i;:::-;54181:43;;54259:58;54281:35;54307:8;54281:21;54297:4;54281:11;:15;;:21;;;;:::i;:::-;:25;;:35;;;;:::i;:::-;54259:17;:21;;:58;;;;:::i;:::-;54239:78;;54166:163;54101:228;54346:65;54395:4;:15;;;54346:44;54385:4;54346:34;54362:17;54346:4;:11;;;:15;;:34;;;;:::i;:::-;:38;;:44;;;;:::i;:::-;:48;;:65;;;;:::i;:::-;54339:72;;;;;;53737:682;;;;:::o;56486:749::-;50404:1;51002:7;;:19;50994:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50404:1;51135:7;:18;;;;56547:22:::1;;;;;;;;;;;56539:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;56600:21;56624:8;56600:32;;56643:21;56667:8;:20;56676:10;56667:20;;;;;;;;;;;;;;;56643:44;;56700:12;:10;:12::i;:::-;56741:1;56727:4;:11;;;:15;56723:389;;;56759:15;56777:70;56831:4;:15;;;56777:49;56821:4;56777:39;56793:4;:22;;;56777:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;56759:88;;56875:1;56865:7;:11;56862:239;;;56916:18;:16;:18::i;:::-;56905:7;:29;;56897:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;57037:7;57022:4;:11;;;:22;;;;;;;:::i;:::-;;;;;;;;57078:7;57063:11;;:22;;;;;;;:::i;:::-;;;;;;;;56862:239;56744:368;56723:389;57142:49;57186:4;57142:39;57158:4;:22;;;57142:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;57124:4;:15;;:67;;;;57216:10;57207:20;;;;;;;;;;;;56528:707;;50360:1:::0;51314:7;:22;;;;56486:749::o;52035:35::-;;;:::o;39869:211::-;39986:86;40006:5;40036:23;;;40061:2;40065:5;40013:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39986:19;:86::i;:::-;39869:211;;;:::o;54495:540::-;54537:21;54561:8;54537:32;;54603:4;:24;;;54584:15;:43;54580:82;;54644:7;;;54580:82;54672:16;54691:11;;54672:30;;54729:1;54717:8;:13;54713:109;;54774:15;54747:4;:24;;:42;;;;54804:7;;;;54713:109;54832:19;54854:21;:19;:21::i;:::-;54832:43;;54911:63;54938:35;54964:8;54938:21;54954:4;54938:11;:15;;:21;;;;:::i;:::-;:25;;:35;;;;:::i;:::-;54911:4;:22;;;:26;;:63;;;;:::i;:::-;54886:4;:22;;:88;;;;55012:15;54985:4;:24;;:42;;;;54526:509;;;54495:540;:::o;32911:471::-;32969:7;33219:1;33214;:6;33210:47;;33244:1;33237:8;;;;33210:47;33269:9;33285:1;33281;:5;;;;:::i;:::-;33269:17;;33314:1;33309;33305;:5;;;;:::i;:::-;:10;33297:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;33373:1;33366:8;;;32911:471;;;;;:::o;33858:132::-;33916:7;33943:39;33947:1;33950;33943:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;33936:46;;33858:132;;;;:::o;31987:136::-;32045:7;32072:43;32076:1;32079;32072:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;32065:50;;31987:136;;;;:::o;40088:248::-;40232:96;40252:5;40282:27;;;40311:4;40317:2;40321:5;40259:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40232:19;:96::i;:::-;40088:248;;;;:::o;31523:181::-;31581:7;31601:9;31617:1;31613;:5;;;;:::i;:::-;31601:17;;31642:1;31637;:6;;31629:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;31695:1;31688:8;;;31523:181;;;;:::o;42404:774::-;42828:23;42854:69;42882:4;42854:69;;;;;;;;;;;;;;;;;42862:5;42854:27;;;;:69;;;;;:::i;:::-;42828:95;;42958:1;42938:10;:17;:21;42934:237;;;43093:10;43082:30;;;;;;;;;;;;:::i;:::-;43074:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;42934:237;42474:704;42404:774;;:::o;34486:312::-;34606:7;34638:1;34634;:5;34641:12;34626:28;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;34665:9;34681:1;34677;:5;;;;:::i;:::-;34665:17;;34789:1;34782:8;;;34486:312;;;;;:::o;32426:226::-;32546:7;32579:1;32574;:6;;32582:12;32566:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;32606:9;32622:1;32618;:5;;;;:::i;:::-;32606:17;;32643:1;32636:8;;;32426:226;;;;;:::o;47003:230::-;47140:12;47172:53;47195:6;47203:4;47209:1;47212:12;47172:22;:53::i;:::-;47165:60;;47003:230;;;;;:::o;48491:1020::-;48664:12;48697:18;48708:6;48697:10;:18::i;:::-;48689:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;48823:12;48837:23;48864:6;:11;;48883:8;48893:4;48864:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48822:76;;;;48913:7;48909:595;;;48944:10;48937:17;;;;;;48909:595;49078:1;49058:10;:17;:21;49054:439;;;49321:10;49315:17;49382:15;49369:10;49365:2;49361:19;49354:44;49054:439;49464:12;49457:20;;;;;;;;;;;:::i;:::-;;;;;;;;48491:1020;;;;;;;:::o;43866:641::-;43926:4;44188:16;44215:19;44237:66;44215:88;;;;44419:7;44407:20;44395:32;;44468:11;44456:8;:23;;:42;;;;;44495:3;44483:15;;:8;:15;;44456:42;44448:51;;;;43866:641;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;523:117::-;632:1;629;622:12;769:90;803:7;846:5;839:13;832:21;821:32;;769:90;;;:::o;865:116::-;935:21;950:5;935:21;:::i;:::-;928:5;925:32;915:60;;971:1;968;961:12;915:60;865:116;:::o;987:133::-;1030:5;1068:6;1055:20;1046:29;;1084:30;1108:5;1084:30;:::i;:::-;987:133;;;;:::o;1126:323::-;1182:6;1231:2;1219:9;1210:7;1206:23;1202:32;1199:119;;;1237:79;;:::i;:::-;1199:119;1357:1;1382:50;1424:7;1415:6;1404:9;1400:22;1382:50;:::i;:::-;1372:60;;1328:114;1126:323;;;;:::o;1455:126::-;1492:7;1532:42;1525:5;1521:54;1510:65;;1455:126;;;:::o;1587:96::-;1624:7;1653:24;1671:5;1653:24;:::i;:::-;1642:35;;1587:96;;;:::o;1689:122::-;1762:24;1780:5;1762:24;:::i;:::-;1755:5;1752:35;1742:63;;1801:1;1798;1791:12;1742:63;1689:122;:::o;1817:139::-;1863:5;1901:6;1888:20;1879:29;;1917:33;1944:5;1917:33;:::i;:::-;1817:139;;;;:::o;1962:329::-;2021:6;2070:2;2058:9;2049:7;2045:23;2041:32;2038:119;;;2076:79;;:::i;:::-;2038:119;2196:1;2221:53;2266:7;2257:6;2246:9;2242:22;2221:53;:::i;:::-;2211:63;;2167:117;1962:329;;;;:::o;2297:332::-;2418:4;2456:2;2445:9;2441:18;2433:26;;2469:71;2537:1;2526:9;2522:17;2513:6;2469:71;:::i;:::-;2550:72;2618:2;2607:9;2603:18;2594:6;2550:72;:::i;:::-;2297:332;;;;;:::o;2635:122::-;2708:24;2726:5;2708:24;:::i;:::-;2701:5;2698:35;2688:63;;2747:1;2744;2737:12;2688:63;2635:122;:::o;2763:139::-;2809:5;2847:6;2834:20;2825:29;;2863:33;2890:5;2863:33;:::i;:::-;2763:139;;;;:::o;2908:329::-;2967:6;3016:2;3004:9;2995:7;2991:23;2987:32;2984:119;;;3022:79;;:::i;:::-;2984:119;3142:1;3167:53;3212:7;3203:6;3192:9;3188:22;3167:53;:::i;:::-;3157:63;;3113:117;2908:329;;;;:::o;3243:60::-;3271:3;3292:5;3285:12;;3243:60;;;:::o;3309:142::-;3359:9;3392:53;3410:34;3419:24;3437:5;3419:24;:::i;:::-;3410:34;:::i;:::-;3392:53;:::i;:::-;3379:66;;3309:142;;;:::o;3457:126::-;3507:9;3540:37;3571:5;3540:37;:::i;:::-;3527:50;;3457:126;;;:::o;3589:141::-;3654:9;3687:37;3718:5;3687:37;:::i;:::-;3674:50;;3589:141;;;:::o;3736:161::-;3838:52;3884:5;3838:52;:::i;:::-;3833:3;3826:65;3736:161;;:::o;3903:472::-;4067:4;4105:2;4094:9;4090:18;4082:26;;4118:86;4201:1;4190:9;4186:17;4177:6;4118:86;:::i;:::-;4214:72;4282:2;4271:9;4267:18;4258:6;4214:72;:::i;:::-;4296;4364:2;4353:9;4349:18;4340:6;4296:72;:::i;:::-;3903:472;;;;;;:::o;4381:109::-;4462:21;4477:5;4462:21;:::i;:::-;4457:3;4450:34;4381:109;;:::o;4496:210::-;4583:4;4621:2;4610:9;4606:18;4598:26;;4634:65;4696:1;4685:9;4681:17;4672:6;4634:65;:::i;:::-;4496:210;;;;:::o;4712:252::-;4820:4;4858:2;4847:9;4843:18;4835:26;;4871:86;4954:1;4943:9;4939:17;4930:6;4871:86;:::i;:::-;4712:252;;;;:::o;4970:118::-;5057:24;5075:5;5057:24;:::i;:::-;5052:3;5045:37;4970:118;;:::o;5094:222::-;5187:4;5225:2;5214:9;5210:18;5202:26;;5238:71;5306:1;5295:9;5291:17;5282:6;5238:71;:::i;:::-;5094:222;;;;:::o;5322:143::-;5379:5;5410:6;5404:13;5395:22;;5426:33;5453:5;5426:33;:::i;:::-;5322:143;;;;:::o;5471:351::-;5541:6;5590:2;5578:9;5569:7;5565:23;5561:32;5558:119;;;5596:79;;:::i;:::-;5558:119;5716:1;5741:64;5797:7;5788:6;5777:9;5773:22;5741:64;:::i;:::-;5731:74;;5687:128;5471:351;;;;:::o;5828:180::-;5876:77;5873:1;5866:88;5973:4;5970:1;5963:15;5997:4;5994:1;5987:15;6014:191;6054:4;6074:20;6092:1;6074:20;:::i;:::-;6069:25;;6108:20;6126:1;6108:20;:::i;:::-;6103:25;;6147:1;6144;6141:8;6138:34;;;6152:18;;:::i;:::-;6138:34;6197:1;6194;6190:9;6182:17;;6014:191;;;;:::o;6211:169::-;6295:11;6329:6;6324:3;6317:19;6369:4;6364:3;6360:14;6345:29;;6211:169;;;;:::o;6386:179::-;6526:31;6522:1;6514:6;6510:14;6503:55;6386:179;:::o;6571:366::-;6713:3;6734:67;6798:2;6793:3;6734:67;:::i;:::-;6727:74;;6810:93;6899:3;6810:93;:::i;:::-;6928:2;6923:3;6919:12;6912:19;;6571:366;;;:::o;6943:419::-;7109:4;7147:2;7136:9;7132:18;7124:26;;7196:9;7190:4;7186:20;7182:1;7171:9;7167:17;7160:47;7224:131;7350:4;7224:131;:::i;:::-;7216:139;;6943:419;;;:::o;7368:181::-;7508:33;7504:1;7496:6;7492:14;7485:57;7368:181;:::o;7555:366::-;7697:3;7718:67;7782:2;7777:3;7718:67;:::i;:::-;7711:74;;7794:93;7883:3;7794:93;:::i;:::-;7912:2;7907:3;7903:12;7896:19;;7555:366;;;:::o;7927:419::-;8093:4;8131:2;8120:9;8116:18;8108:26;;8180:9;8174:4;8170:20;8166:1;8155:9;8151:17;8144:47;8208:131;8334:4;8208:131;:::i;:::-;8200:139;;7927:419;;;:::o;8352:182::-;8492:34;8488:1;8480:6;8476:14;8469:58;8352:182;:::o;8540:366::-;8682:3;8703:67;8767:2;8762:3;8703:67;:::i;:::-;8696:74;;8779:93;8868:3;8779:93;:::i;:::-;8897:2;8892:3;8888:12;8881:19;;8540:366;;;:::o;8912:419::-;9078:4;9116:2;9105:9;9101:18;9093:26;;9165:9;9159:4;9155:20;9151:1;9140:9;9136:17;9129:47;9193:131;9319:4;9193:131;:::i;:::-;9185:139;;8912:419;;;:::o;9337:251::-;9477:34;9473:1;9465:6;9461:14;9454:58;9546:34;9541:2;9533:6;9529:15;9522:59;9337:251;:::o;9594:366::-;9736:3;9757:67;9821:2;9816:3;9757:67;:::i;:::-;9750:74;;9833:93;9922:3;9833:93;:::i;:::-;9951:2;9946:3;9942:12;9935:19;;9594:366;;;:::o;9966:419::-;10132:4;10170:2;10159:9;10155:18;10147:26;;10219:9;10213:4;10209:20;10205:1;10194:9;10190:17;10183:47;10247:131;10373:4;10247:131;:::i;:::-;10239:139;;9966:419;;;:::o;10391:305::-;10431:3;10450:20;10468:1;10450:20;:::i;:::-;10445:25;;10484:20;10502:1;10484:20;:::i;:::-;10479:25;;10638:1;10570:66;10566:74;10563:1;10560:81;10557:107;;;10644:18;;:::i;:::-;10557:107;10688:1;10685;10681:9;10674:16;;10391:305;;;;:::o;10702:177::-;10842:29;10838:1;10830:6;10826:14;10819:53;10702:177;:::o;10885:366::-;11027:3;11048:67;11112:2;11107:3;11048:67;:::i;:::-;11041:74;;11124:93;11213:3;11124:93;:::i;:::-;11242:2;11237:3;11233:12;11226:19;;10885:366;;;:::o;11257:419::-;11423:4;11461:2;11450:9;11446:18;11438:26;;11510:9;11504:4;11500:20;11496:1;11485:9;11481:17;11474:47;11538:131;11664:4;11538:131;:::i;:::-;11530:139;;11257:419;;;:::o;11682:174::-;11822:26;11818:1;11810:6;11806:14;11799:50;11682:174;:::o;11862:366::-;12004:3;12025:67;12089:2;12084:3;12025:67;:::i;:::-;12018:74;;12101:93;12190:3;12101:93;:::i;:::-;12219:2;12214:3;12210:12;12203:19;;11862:366;;;:::o;12234:419::-;12400:4;12438:2;12427:9;12423:18;12415:26;;12487:9;12481:4;12477:20;12473:1;12462:9;12458:17;12451:47;12515:131;12641:4;12515:131;:::i;:::-;12507:139;;12234:419;;;:::o;12659:177::-;12799:29;12795:1;12787:6;12783:14;12776:53;12659:177;:::o;12842:366::-;12984:3;13005:67;13069:2;13064:3;13005:67;:::i;:::-;12998:74;;13081:93;13170:3;13081:93;:::i;:::-;13199:2;13194:3;13190:12;13183:19;;12842:366;;;:::o;13214:419::-;13380:4;13418:2;13407:9;13403:18;13395:26;;13467:9;13461:4;13457:20;13453:1;13442:9;13438:17;13431:47;13495:131;13621:4;13495:131;:::i;:::-;13487:139;;13214:419;;;:::o;13639:348::-;13679:7;13702:20;13720:1;13702:20;:::i;:::-;13697:25;;13736:20;13754:1;13736:20;:::i;:::-;13731:25;;13924:1;13856:66;13852:74;13849:1;13846:81;13841:1;13834:9;13827:17;13823:105;13820:131;;;13931:18;;:::i;:::-;13820:131;13979:1;13976;13972:9;13961:20;;13639:348;;;;:::o;13993:180::-;14041:77;14038:1;14031:88;14138:4;14135:1;14128:15;14162:4;14159:1;14152:15;14179:185;14219:1;14236:20;14254:1;14236:20;:::i;:::-;14231:25;;14270:20;14288:1;14270:20;:::i;:::-;14265:25;;14309:1;14299:35;;14314:18;;:::i;:::-;14299:35;14356:1;14353;14349:9;14344:14;;14179:185;;;;:::o;14370:167::-;14510:19;14506:1;14498:6;14494:14;14487:43;14370:167;:::o;14543:366::-;14685:3;14706:67;14770:2;14765:3;14706:67;:::i;:::-;14699:74;;14782:93;14871:3;14782:93;:::i;:::-;14900:2;14895:3;14891:12;14884:19;;14543:366;;;:::o;14915:419::-;15081:4;15119:2;15108:9;15104:18;15096:26;;15168:9;15162:4;15158:20;15154:1;15143:9;15139:17;15132:47;15196:131;15322:4;15196:131;:::i;:::-;15188:139;;14915:419;;;:::o;15340:179::-;15480:31;15476:1;15468:6;15464:14;15457:55;15340:179;:::o;15525:366::-;15667:3;15688:67;15752:2;15747:3;15688:67;:::i;:::-;15681:74;;15764:93;15853:3;15764:93;:::i;:::-;15882:2;15877:3;15873:12;15866:19;;15525:366;;;:::o;15897:419::-;16063:4;16101:2;16090:9;16086:18;16078:26;;16150:9;16144:4;16140:20;16136:1;16125:9;16121:17;16114:47;16178:131;16304:4;16178:131;:::i;:::-;16170:139;;15897:419;;;:::o;16322:165::-;16462:17;16458:1;16450:6;16446:14;16439:41;16322:165;:::o;16493:366::-;16635:3;16656:67;16720:2;16715:3;16656:67;:::i;:::-;16649:74;;16732:93;16821:3;16732:93;:::i;:::-;16850:2;16845:3;16841:12;16834:19;;16493:366;;;:::o;16865:419::-;17031:4;17069:2;17058:9;17054:18;17046:26;;17118:9;17112:4;17108:20;17104:1;17093:9;17089:17;17082:47;17146:131;17272:4;17146:131;:::i;:::-;17138:139;;16865:419;;;:::o;17290:332::-;17411:4;17449:2;17438:9;17434:18;17426:26;;17462:71;17530:1;17519:9;17515:17;17506:6;17462:71;:::i;:::-;17543:72;17611:2;17600:9;17596:18;17587:6;17543:72;:::i;:::-;17290:332;;;;;:::o;17628:220::-;17768:34;17764:1;17756:6;17752:14;17745:58;17837:3;17832:2;17824:6;17820:15;17813:28;17628:220;:::o;17854:366::-;17996:3;18017:67;18081:2;18076:3;18017:67;:::i;:::-;18010:74;;18093:93;18182:3;18093:93;:::i;:::-;18211:2;18206:3;18202:12;18195:19;;17854:366;;;:::o;18226:419::-;18392:4;18430:2;18419:9;18415:18;18407:26;;18479:9;18473:4;18469:20;18465:1;18454:9;18450:17;18443:47;18507:131;18633:4;18507:131;:::i;:::-;18499:139;;18226:419;;;:::o;18651:442::-;18800:4;18838:2;18827:9;18823:18;18815:26;;18851:71;18919:1;18908:9;18904:17;18895:6;18851:71;:::i;:::-;18932:72;19000:2;18989:9;18985:18;18976:6;18932:72;:::i;:::-;19014;19082:2;19071:9;19067:18;19058:6;19014:72;:::i;:::-;18651:442;;;;;;:::o;19099:177::-;19239:29;19235:1;19227:6;19223:14;19216:53;19099:177;:::o;19282:366::-;19424:3;19445:67;19509:2;19504:3;19445:67;:::i;:::-;19438:74;;19521:93;19610:3;19521:93;:::i;:::-;19639:2;19634:3;19630:12;19623:19;;19282:366;;;:::o;19654:419::-;19820:4;19858:2;19847:9;19843:18;19835:26;;19907:9;19901:4;19897:20;19893:1;19882:9;19878:17;19871:47;19935:131;20061:4;19935:131;:::i;:::-;19927:139;;19654:419;;;:::o;20079:137::-;20133:5;20164:6;20158:13;20149:22;;20180:30;20204:5;20180:30;:::i;:::-;20079:137;;;;:::o;20222:345::-;20289:6;20338:2;20326:9;20317:7;20313:23;20309:32;20306:119;;;20344:79;;:::i;:::-;20306:119;20464:1;20489:61;20542:7;20533:6;20522:9;20518:22;20489:61;:::i;:::-;20479:71;;20435:125;20222:345;;;;:::o;20573:229::-;20713:34;20709:1;20701:6;20697:14;20690:58;20782:12;20777:2;20769:6;20765:15;20758:37;20573:229;:::o;20808:366::-;20950:3;20971:67;21035:2;21030:3;20971:67;:::i;:::-;20964:74;;21047:93;21136:3;21047:93;:::i;:::-;21165:2;21160:3;21156:12;21149:19;;20808:366;;;:::o;21180:419::-;21346:4;21384:2;21373:9;21369:18;21361:26;;21433:9;21427:4;21423:20;21419:1;21408:9;21404:17;21397:47;21461:131;21587:4;21461:131;:::i;:::-;21453:139;;21180:419;;;:::o;21605:99::-;21657:6;21691:5;21685:12;21675:22;;21605:99;;;:::o;21710:307::-;21778:1;21788:113;21802:6;21799:1;21796:13;21788:113;;;21887:1;21882:3;21878:11;21872:18;21868:1;21863:3;21859:11;21852:39;21824:2;21821:1;21817:10;21812:15;;21788:113;;;21919:6;21916:1;21913:13;21910:101;;;21999:1;21990:6;21985:3;21981:16;21974:27;21910:101;21759:258;21710:307;;;:::o;22023:102::-;22064:6;22115:2;22111:7;22106:2;22099:5;22095:14;22091:28;22081:38;;22023:102;;;:::o;22131:364::-;22219:3;22247:39;22280:5;22247:39;:::i;:::-;22302:71;22366:6;22361:3;22302:71;:::i;:::-;22295:78;;22382:52;22427:6;22422:3;22415:4;22408:5;22404:16;22382:52;:::i;:::-;22459:29;22481:6;22459:29;:::i;:::-;22454:3;22450:39;22443:46;;22223:272;22131:364;;;;:::o;22501:313::-;22614:4;22652:2;22641:9;22637:18;22629:26;;22701:9;22695:4;22691:20;22687:1;22676:9;22672:17;22665:47;22729:78;22802:4;22793:6;22729:78;:::i;:::-;22721:86;;22501:313;;;;:::o;22820:179::-;22960:31;22956:1;22948:6;22944:14;22937:55;22820:179;:::o;23005:366::-;23147:3;23168:67;23232:2;23227:3;23168:67;:::i;:::-;23161:74;;23244:93;23333:3;23244:93;:::i;:::-;23362:2;23357:3;23353:12;23346:19;;23005:366;;;:::o;23377:419::-;23543:4;23581:2;23570:9;23566:18;23558:26;;23630:9;23624:4;23620:20;23616:1;23605:9;23601:17;23594:47;23658:131;23784:4;23658:131;:::i;:::-;23650:139;;23377:419;;;:::o;23802:98::-;23853:6;23887:5;23881:12;23871:22;;23802:98;;;:::o;23906:147::-;24007:11;24044:3;24029:18;;23906:147;;;;:::o;24059:373::-;24163:3;24191:38;24223:5;24191:38;:::i;:::-;24245:88;24326:6;24321:3;24245:88;:::i;:::-;24238:95;;24342:52;24387:6;24382:3;24375:4;24368:5;24364:16;24342:52;:::i;:::-;24419:6;24414:3;24410:16;24403:23;;24167:265;24059:373;;;;:::o;24438:271::-;24568:3;24590:93;24679:3;24670:6;24590:93;:::i;:::-;24583:100;;24700:3;24693:10;;24438:271;;;;:::o
Swarm Source
ipfs://078aea9a68930801b6356094dda7b694bb34594afc157cb4cc981b3b4654049d
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
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.