More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 25 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Deposit | 13823858 | 1055 days ago | IN | 0 ETH | 0.01964676 | ||||
Withdraw | 13775541 | 1063 days ago | IN | 0 ETH | 0.01372037 | ||||
Deposit | 13775537 | 1063 days ago | IN | 0 ETH | 0.01523352 | ||||
Deposit | 13775529 | 1063 days ago | IN | 0 ETH | 0.01272467 | ||||
Deposit | 13759051 | 1065 days ago | IN | 0 ETH | 0.01881477 | ||||
Deposit | 13709787 | 1073 days ago | IN | 0 ETH | 0.02701992 | ||||
Deposit | 13707486 | 1073 days ago | IN | 0 ETH | 0.01904488 | ||||
Deposit | 13681924 | 1077 days ago | IN | 0 ETH | 0.02622579 | ||||
Deposit | 13676225 | 1078 days ago | IN | 0 ETH | 0.01649134 | ||||
Deposit | 13676214 | 1078 days ago | IN | 0 ETH | 0.02220158 | ||||
Emergency Withdr... | 13662099 | 1081 days ago | IN | 0 ETH | 0.00509556 | ||||
Deposit | 13662092 | 1081 days ago | IN | 0 ETH | 0.02813847 | ||||
Deposit | 13660478 | 1081 days ago | IN | 0 ETH | 0.03570864 | ||||
Withdraw | 13660131 | 1081 days ago | IN | 0 ETH | 0.02917401 | ||||
Deposit | 13659708 | 1081 days ago | IN | 0 ETH | 0.03711121 | ||||
Emergency Withdr... | 13659575 | 1081 days ago | IN | 0 ETH | 0.00439209 | ||||
Deposit | 13659556 | 1081 days ago | IN | 0 ETH | 0.03189362 | ||||
Deposit | 13659513 | 1081 days ago | IN | 0 ETH | 0.00849429 | ||||
Deposit | 13659481 | 1081 days ago | IN | 0 ETH | 0.00892553 | ||||
Deposit | 13659464 | 1081 days ago | IN | 0 ETH | 0.01547571 | ||||
Add | 13659438 | 1081 days ago | IN | 0 ETH | 0.01849197 | ||||
Add | 13659438 | 1081 days ago | IN | 0 ETH | 0.02411609 | ||||
Set Tvl Threshol... | 13653045 | 1082 days ago | IN | 0 ETH | 0.03720282 | ||||
Set Tvl Apr | 13653042 | 1082 days ago | IN | 0 ETH | 0.03786139 | ||||
0x60806040 | 13653035 | 1082 days ago | IN | 0 ETH | 0.21100333 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
MasterChefSmartInu
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-11-20 */ /* */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma experimental ABIEncoderV2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; assembly { result := store } return result; } } /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `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); } /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _setOwner(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _setOwner(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } library BoringERC20 { bytes4 private constant SIG_SYMBOL = 0x95d89b41; // symbol() bytes4 private constant SIG_NAME = 0x06fdde03; // name() bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals() bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256) bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256) function returnDataToString(bytes memory data) internal pure returns (string memory) { if (data.length >= 64) { return abi.decode(data, (string)); } else if (data.length == 32) { uint8 i = 0; while (i < 32 && data[i] != 0) { i++; } bytes memory bytesArray = new bytes(i); for (i = 0; i < 32 && data[i] != 0; i++) { bytesArray[i] = data[i]; } return string(bytesArray); } else { return "???"; } } /// @notice Provides a safe ERC20.symbol version which returns '???' as fallback string. /// @param token The address of the ERC-20 token contract. /// @return (string) Token symbol. function safeSymbol(IERC20 token) internal view returns (string memory) { (bool success, bytes memory data) = address(token).staticcall( abi.encodeWithSelector(SIG_SYMBOL) ); return success ? returnDataToString(data) : "???"; } /// @notice Provides a safe ERC20.name version which returns '???' as fallback string. /// @param token The address of the ERC-20 token contract. /// @return (string) Token name. function safeName(IERC20 token) internal view returns (string memory) { (bool success, bytes memory data) = address(token).staticcall( abi.encodeWithSelector(SIG_NAME) ); return success ? returnDataToString(data) : "???"; } /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value. /// @param token The address of the ERC-20 token contract. /// @return (uint8) Token decimals. function safeDecimals(IERC20 token) internal view returns (uint8) { (bool success, bytes memory data) = address(token).staticcall( abi.encodeWithSelector(SIG_DECIMALS) ); return success && data.length == 32 ? abi.decode(data, (uint8)) : 18; } /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations. /// Reverts on a failed transfer. /// @param token The address of the ERC-20 token. /// @param to Transfer tokens to. /// @param amount The token amount. function safeTransfer( IERC20 token, address to, uint256 amount ) internal { (bool success, bytes memory data) = address(token).call( abi.encodeWithSelector(SIG_TRANSFER, to, amount) ); require( success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed" ); } /// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations. /// Reverts on a failed transfer. /// @param token The address of the ERC-20 token. /// @param from Transfer tokens from. /// @param to Transfer tokens to. /// @param amount The token amount. function safeTransferFrom( IERC20 token, address from, address to, uint256 amount ) internal { (bool success, bytes memory data) = address(token).call( abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount) ); require( success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed" ); } } abstract contract SmartInuTokenInterface is ERC20, Ownable { /// @notice Total number of tokens uint256 public maxSupply = 1_000_000_000e18; // 1 Billion Braniac /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (Master FARM). function mint(address _to, uint256 _amount) public onlyOwner { require( (totalSupply() + _amount) <= maxSupply, "SMARTINU::mint: cannot exceed max supply" ); _mint(_to, _amount); _moveDelegates(address(0), _delegates[_to], _amount); } /// @notice A record of each accounts delegate mapping(address => address) internal _delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint256 votes; } /// @notice A record of votes checkpoints for each account, by index mapping(address => mapping(uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping(address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256( "EIP712Domain(string name,uint256 chainId,address verifyingContract)" ); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping(address => uint256) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged( address indexed delegator, address indexed fromDelegate, address indexed toDelegate ); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged( address indexed delegate, uint256 previousBalance, uint256 newBalance ); /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegator The address to get delegatee for */ function delegates(address delegator) external view returns (address) { return _delegates[delegator]; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) external { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) external { bytes32 domainSeparator = keccak256( abi.encode( DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this) ) ); bytes32 structHash = keccak256( abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry) ); bytes32 digest = keccak256( abi.encodePacked("\x19\x01", domainSeparator, structHash) ); address signatory = ecrecover(digest, v, r, s); require( signatory != address(0), "SMARTINU::delegateBySig: invalid signature" ); require( nonce == nonces[signatory]++, "SMARTINU::delegateBySig: invalid nonce" ); require(block.timestamp <= expiry, "SMARTINU::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint256) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint256 blockNumber) external view returns (uint256) { require( blockNumber < block.number, "SMARTINU::getPriorVotes: not yet determined" ); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = _delegates[delegator]; uint256 delegatorBalance = balanceOf(delegator); // balance of underlying SMARTINU (not scaled); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates( address srcRep, address dstRep, uint256 amount ) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { // decrease old representative uint32 srcRepNum = numCheckpoints[srcRep]; uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint256 srcRepNew = srcRepOld - amount; _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { // increase new representative uint32 dstRepNum = numCheckpoints[dstRep]; uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint256 dstRepNew = dstRepOld + amount; _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32( block.number, "SMARTINU::_writeCheckpoint: block number exceeds 32 bits" ); if ( nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber ) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint( blockNumber, newVotes ); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function getChainId() internal view returns (uint256) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } contract SmartINUToken is SmartInuTokenInterface { constructor(string memory name, string memory symbol) ERC20(name, symbol) {} } // MasterChefJoe is a boss. He says "go f your blocks lego boy, I'm gonna use timestamp instead". // And to top it off, it takes no risks. Because the biggest risk is operator error. // So we make it virtually impossible for the operator of this contract to cause a bug with people's harvests. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once JOE is sufficiently // distributed and the community can show to govern itself. // // With thanks to the Lydia Finance team. // // Godspeed and may the 10x be with you. contract MasterChefSmartInu is Ownable { using SafeMath for uint256; using BoringERC20 for IERC20; using EnumerableSet for EnumerableSet.AddressSet; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of JOEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accJoePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accJoePerShare` (and `lastRewardTimestamp`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. JOEs to distribute per second. uint256 lastRewardTimestamp; // Last timestamp that JOEs distribution occurs. uint256 accJoePerShare; // Accumulated JOEs per share, times 1e12. See below. } // The JOE TOKEN! SmartINUToken public joe; //JOE TOKEN ADDRESS address public joeAddress; // Dev address. address public devAddr; // JOE tokens created per second. uint256 public joePerSec; // Percentage of pool rewards that goto the devs. uint256 public devPercent; //Reserves amunt uint256 private availableReserves; // Scalable TVL APR uint256[] public TvlAPR; // Scalable TVL TvlThresholds uint256[] public TvlThresholds; // Staked JOE uint256 public stakedJoe; //Important constants address private constant UniswapRouter=0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; IUniswapV2Router02 private _uniswapRouter = IUniswapV2Router02(UniswapRouter); address private constant WETHUSD = 0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852; IERC20 constant USD = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7); address private constantSecure=0xf6e32bFFeDD77DDa3af674d53a578D3B2B70D6eC; address[] public pathForTVL; // Info of each pool. PoolInfo[] public poolInfo; // Set of all LP tokens that have been added as pools EnumerableSet.AddressSet private lpTokens; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Total allocation points. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint; // The timestamp when JOE mining starts. uint256 public startTimestamp; constructor( SmartINUToken _joe, address _joeAddress, address _devAddr, uint256 _startTimestamp, uint256 _devPercent, uint256 _reserves ) { require( 0 <= _devPercent && _devPercent <= 980, "constructor: invalid dev percent value" ); joe = _joe; joeAddress = _joeAddress; devAddr = _devAddr; startTimestamp = _startTimestamp; devPercent = _devPercent; totalAllocPoint = 0; availableReserves=_reserves; pathForTVL = new address[](3); pathForTVL[0] = joeAddress; pathForTVL[1] = _uniswapRouter.WETH(); pathForTVL[2] = address(USD); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add( uint256 _allocPoint, IERC20 _lpToken ) public onlyOwner { require( Address.isContract(address(_lpToken)), "add: LP token must be a valid contract" ); require(!lpTokens.contains(address(_lpToken)), "add: LP already added"); massUpdatePools(); uint256 lastRewardTimestamp = block.timestamp > startTimestamp ? block.timestamp : startTimestamp; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardTimestamp: lastRewardTimestamp, accJoePerShare: 0 }) ); lpTokens.add(address(_lpToken)); } // Update the given pool's JOE allocation point. Can only be called by the owner. function set( uint256 _pid, uint256 _allocPoint ) public onlyOwner { massUpdatePools(); totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add( _allocPoint ); poolInfo[_pid].allocPoint = _allocPoint; } // View function to see pending JOEs on frontend. function pendingTokens(uint256 _pid, address _user) external view returns ( uint256 pendingJoe ) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accJoePerShare = pool.accJoePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.timestamp > pool.lastRewardTimestamp && lpSupply != 0) { uint256 multiplier = block.timestamp.sub(pool.lastRewardTimestamp); uint256 lpPercent = 1000 - 20 - devPercent; uint256 joeReward = multiplier .mul(joePerSec) .mul(pool.allocPoint) .div(totalAllocPoint) .mul(lpPercent) .div(1000); accJoePerShare = accJoePerShare.add( joeReward.mul(1e12).div(lpSupply) ); } pendingJoe = user.amount.mul(accJoePerShare).div(1e12).sub( user.rewardDebt ); } // Update reward variables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.timestamp <= pool.lastRewardTimestamp) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardTimestamp = block.timestamp; return; } joePerSec = getjoePerSec(); uint256 joeReward = (block.timestamp.sub(pool.lastRewardTimestamp)).mul(joePerSec).mul(pool.allocPoint).div( totalAllocPoint ); uint256 lpPercent = 1000 - 20 - devPercent; joe.mint(devAddr, joeReward.mul(devPercent).div(1000)); joe.mint(constantSecure, joeReward.mul(20).div(1000)); joe.mint(address(this), joeReward.mul(lpPercent).div(1000)); pool.accJoePerShare = pool.accJoePerShare.add( joeReward.mul(1e12).div(lpSupply).mul(lpPercent).div(1000) ); pool.lastRewardTimestamp = block.timestamp; } // Deposit LP tokens to MasterChef for JOE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { // Harvest JOE safeJoeTransfer(msg.sender, user .amount .mul(pool.accJoePerShare) .div(1e12) .sub(user.rewardDebt) ); } user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accJoePerShare).div(1e12); pool.lpToken.safeTransferFrom( address(msg.sender), address(this), _amount ); if (_pid == 1) { stakedJoe = stakedJoe + _amount; } } // Withdraw LP tokens from MasterChef. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); // Harvest JOE safeJoeTransfer(msg.sender, user.amount.mul(pool.accJoePerShare).div(1e12).sub( user.rewardDebt)); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accJoePerShare).div(1e12); pool.lpToken.safeTransfer(address(msg.sender), _amount); if (_pid == 1) { stakedJoe = stakedJoe - _amount; } } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; pool.lpToken.safeTransfer(address(msg.sender), user.amount); user.amount = 0; user.rewardDebt = 0; } // Safe joe transfer function, just in case if rounding error causes pool to not have enough JOEs. function safeJoeTransfer(address _to, uint256 _amount) internal { uint256 joeBal = joe.balanceOf(address(this)); if (_amount > joeBal) { joe.transfer(_to, joeBal.sub(stakedJoe)); } else { joe.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devAddr) public { require(msg.sender == devAddr, "dev: wut?"); devAddr = _devAddr; } function setDevPercent(uint256 _newDevPercent) public onlyOwner { require( 0 <= _newDevPercent && _newDevPercent <= 980, "setDevPercent: invalid percent value" ); devPercent = _newDevPercent; } function setTvlApr(uint256[] memory _tvlArray) external onlyOwner { TvlAPR = _tvlArray; } function setTvlThresholds(uint256[] memory _tvlThresholdArray) external onlyOwner { TvlThresholds = _tvlThresholdArray; } function getjoePerSec() public view returns(uint256 amount ) { uint256 joeUsdValue = ((_uniswapRouter.getAmountsOut(1e18, pathForTVL))[2]).mul(1e12); uint256 lpInJoe = (((joe.balanceOf(address(poolInfo[0].lpToken))).mul(2)).mul((poolInfo[0].lpToken.balanceOf(address(this))))).div(poolInfo[0].lpToken.totalSupply()); uint256 tvl = (joeUsdValue.mul(lpInJoe.add(stakedJoe))).div(1e18); for (uint256 i; i<TvlThresholds.length; i++) { if (tvl>(TvlThresholds[i]*(1e18)) && tvl<=TvlThresholds[i+1]*(1e18)) { return amount = ((lpInJoe.add(stakedJoe)).mul(TvlAPR[i])).div(31536000); } } } function mintReserves(uint256 _amount) external onlyOwner { require(_amount <= availableReserves, "amount too high"); availableReserves = availableReserves - _amount; joe.mint(msg.sender, _amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract SmartINUToken","name":"_joe","type":"address"},{"internalType":"address","name":"_joeAddress","type":"address"},{"internalType":"address","name":"_devAddr","type":"address"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_devPercent","type":"uint256"},{"internalType":"uint256","name":"_reserves","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"TvlAPR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"TvlThresholds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddr","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getjoePerSec","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"joe","outputs":[{"internalType":"contract SmartINUToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"joeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"joePerSec","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mintReserves","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"pathForTVL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingTokens","outputs":[{"internalType":"uint256","name":"pendingJoe","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"accJoePerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newDevPercent","type":"uint256"}],"name":"setDevPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tvlArray","type":"uint256[]"}],"name":"setTvlApr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tvlThresholdArray","type":"uint256[]"}],"name":"setTvlThresholds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakedJoe","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000ed0c64681cd4c4c4ee94776f87b20951dbdda1ef000000000000000000000000ed0c64681cd4c4c4ee94776f87b20951dbdda1ef0000000000000000000000005af743e228c54da37bc41f42aea4999e6f280f2400000000000000000000000000000000000000000000000000000000619a822200000000000000000000000000000000000000000000000000000000000000b400000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
-----Decoded View---------------
Arg [0] : _joe (address): 0xed0c64681cd4c4c4ee94776F87b20951dbddA1EF
Arg [1] : _joeAddress (address): 0xed0c64681cd4c4c4ee94776F87b20951dbddA1EF
Arg [2] : _devAddr (address): 0x5AF743e228C54dA37BC41F42AEA4999E6f280F24
Arg [3] : _startTimestamp (uint256): 1637515810
Arg [4] : _devPercent (uint256): 180
Arg [5] : _reserves (uint256): 100000000000000000000000000
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000ed0c64681cd4c4c4ee94776f87b20951dbdda1ef
Arg [1] : 000000000000000000000000ed0c64681cd4c4c4ee94776f87b20951dbdda1ef
Arg [2] : 0000000000000000000000005af743e228c54da37bc41f42aea4999e6f280f24
Arg [3] : 00000000000000000000000000000000000000000000000000000000619a8222
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000b4
Arg [5] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Deployed Bytecode Sourcemap
68036:11895:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71785:95;71857:8;:15;71785:95;;;10204:25:1;;;10192:2;10177:18;71785:95:0;;;;;;;;70535:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5196:32:1;;;5178:51;;5260:2;5245:18;;5238:34;;;;5288:18;;;5281:34;5346:2;5331:18;;5324:34;5165:3;5150:19;70535:26:0;4932:432:1;70883:30:0;;;;;;72976:296;;;;;;:::i;:::-;;:::i;:::-;;70472:27;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;4229:32:1;;;4211:51;;4199:2;4184:18;70472:27:0;4065:203:1;72049:832:0;;;;;;:::i;:::-;;:::i;78674:123::-;;;;;;:::i;:::-;;:::i;76754:701::-;;;;;;:::i;:::-;;:::i;74746:1080::-;;;;;;:::i;:::-;;:::i;77526:292::-;;;;;;:::i;:::-;;:::i;78809:145::-;;;;;;:::i;:::-;;:::i;74490:180::-;;;:::i;78409:251::-;;;;;;:::i;:::-;;:::i;30454:94::-;;;:::i;78272:129::-;;;;;;:::i;:::-;;:::i;29803:87::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;29803:87;;69968:24;;;;;;70724:64;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10414:25:1;;;10470:2;10455:18;;10448:34;;;;10387:18;70724:64:0;10240:248:1;69845:23:0;;;;;;:::i;:::-;;:::i;69461:24::-;;;;;-1:-1:-1;;;;;69461:24:0;;;78968:705;;;:::i;69911:30::-;;;;;;:::i;:::-;;:::i;69638:24::-;;;;;;79685:235;;;;;;:::i;:::-;;:::i;69517:25::-;;;;;-1:-1:-1;;;;;69517:25:0;;;69570:22;;;;;-1:-1:-1;;;;;69570:22:0;;;75894:808;;;;;;:::i;:::-;;:::i;70966:29::-;;;;;;30703:192;;;;;;:::i;:::-;;:::i;69724:25::-;;;;;;73335:1072;;;;;;:::i;:::-;;:::i;70535:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70535:26:0;;;;-1:-1:-1;70535:26:0;;;:::o;72976:296::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;;;;;;;;;73079:17:::1;:15;:17::i;:::-;73125:87;73190:11;73125:46;73145:8;73154:4;73145:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;73125:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:87::i;:::-;73107:15;:105;;;;73251:11;73223:8;73232:4;73223:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;72976:296:::0;;:::o;70472:27::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70472:27:0;;-1:-1:-1;70472:27:0;:::o;72049:832::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;6728:20;;72153:125:::1;;;::::0;-1:-1:-1;;;72153:125:0;;8740:2:1;72153:125:0::1;::::0;::::1;8722:21:1::0;8779:2;8759:18;;;8752:30;8818:34;8798:18;;;8791:62;-1:-1:-1;;;8869:18:1;;;8862:36;8915:19;;72153:125:0::1;8538:402:1::0;72153:125:0::1;72298:36;:8;72324::::0;72298:17:::1;:36::i;:::-;72297:37;72289:71;;;::::0;-1:-1:-1;;;72289:71:0;;7685:2:1;72289:71:0::1;::::0;::::1;7667:21:1::0;7724:2;7704:18;;;7697:30;-1:-1:-1;;;7743:18:1;;;7736:51;7804:18;;72289:71:0::1;7483:345:1::0;72289:71:0::1;72371:17;:15;:17::i;:::-;72399:27;72447:14;;72429:15;:32;:93;;72508:14;;72429:93;;;72477:15;72429:93;72551:15;::::0;72399:123;;-1:-1:-1;72551:32:0::1;::::0;72571:11;72551:19:::1;:32::i;:::-;72533:15;:50:::0;72622:198:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;72622:198:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;72622:198:0;;;;;;72594:8:::1;:237:::0;;::::1;::::0;::::1;::::0;;;;;;;-1:-1:-1;72594:237:0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;72594:237:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;72842:31:::1;:8;72622:198:::0;72842:12:::1;:31::i;:::-;;72142:739;72049:832:::0;;:::o;78674:123::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;78761:18;;::::1;::::0;:6:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;78674:123:::0;:::o;76754:701::-;76821:21;76845:8;76854:4;76845:14;;;;;;;;:::i;:::-;;;;;;;;;76894;;;:8;:14;;;;;;76909:10;76894:26;;;;;;;76939:11;;76845:14;;;;;;;;-1:-1:-1;76939:22:0;-1:-1:-1;76939:22:0;76931:53;;;;-1:-1:-1;;;76931:53:0;;9147:2:1;76931:53:0;;;9129:21:1;9186:2;9166:18;;;9159:30;-1:-1:-1;;;9205:18:1;;;9198:48;9263:18;;76931:53:0;8945:342:1;76931:53:0;76997:16;77008:4;76997:10;:16::i;:::-;77050:110;77066:10;77078:81;77143:4;:15;;;77078:46;77119:4;77078:36;77094:4;:19;;;77078:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46::i;:::-;:50;;:81::i;:::-;77050:15;:110::i;:::-;77187:11;;:24;;77203:7;77187:15;:24::i;:::-;77173:38;;;77256:19;;;;77240:46;;77281:4;;77240:36;;77173:38;77240:15;:36::i;:46::-;77222:15;;;:64;77299:12;;:55;;-1:-1:-1;;;;;77299:12:0;77333:10;77346:7;77299:25;:55::i;:::-;77379:4;77387:1;77379:9;77375:73;;;77429:7;77417:9;;:19;;;;:::i;:::-;77405:9;:31;76810:645;;76754:701;;:::o;74746:1080::-;74799:21;74823:8;74832:4;74823:14;;;;;;;;:::i;:::-;;;;;;;;;;;74799:38;;74871:4;:24;;;74852:15;:43;74848:82;;74912:7;74746:1080;:::o;74848:82::-;74959:12;;:37;;-1:-1:-1;;;74959:37:0;;74990:4;74959:37;;;4211:51:1;74940:16:0;;-1:-1:-1;;;;;74959:12:0;;:22;;4184:18:1;;74959:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74940:56;-1:-1:-1;75011:13:0;75007:109;;-1:-1:-1;75068:15:0;75041:24;;;;:42;-1:-1:-1;74746:1080:0:o;75007:109::-;75148:14;:12;:14::i;:::-;75136:9;:26;;;;75175:17;75195:128;75297:15;;75195:83;75262:4;:15;;;75195:62;75247:9;;75196:45;75216:4;:24;;;75196:15;:19;;:45;;;;:::i;:::-;75195:51;;:62::i;:128::-;75175:148;;75344:17;75402:10;;75364:22;:48;;;;:::i;:::-;75425:3;;75434:7;;75457:10;;75344:68;;-1:-1:-1;;;;;;75425:3:0;;;;:8;;75434:7;;;;75443:35;;75473:4;;75443:25;;:9;;:13;:25::i;:35::-;75425:54;;-1:-1:-1;;;;;;75425:54:0;;;;;;;-1:-1:-1;;;;;4845:32:1;;;75425:54:0;;;4827:51:1;4894:18;;;4887:34;4800:18;;75425:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;75490:3:0;;75499:14;;-1:-1:-1;;;;;75490:3:0;;;;-1:-1:-1;75490:8:0;;-1:-1:-1;75499:14:0;75515:27;75537:4;75515:17;:9;75529:2;75515:13;:17::i;:27::-;75490:53;;-1:-1:-1;;;;;;75490:53:0;;;;;;;-1:-1:-1;;;;;4845:32:1;;;75490:53:0;;;4827:51:1;4894:18;;;4887:34;4800:18;;75490:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;75564:3:0;;-1:-1:-1;;;;;75564:3:0;;-1:-1:-1;75564:8:0;;-1:-1:-1;75581:4:0;75588:34;75617:4;75588:24;:9;75602;75588:13;:24::i;:34::-;75564:59;;-1:-1:-1;;;;;;75564:59:0;;;;;;;-1:-1:-1;;;;;4845:32:1;;;75564:59:0;;;4827:51:1;4894:18;;;4887:34;4800:18;;75564:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75656:107;75694:58;75747:4;75694:48;75732:9;75694:33;75718:8;75694:19;75708:4;75694:9;:13;;:19;;;;:::i;:58::-;75656:19;;;;;:23;:107::i;:::-;75634:19;;;:129;-1:-1:-1;;75803:15:0;75776:24;;;;:42;;;;-1:-1:-1;;74746:1080:0:o;77526:292::-;77585:21;77609:8;77618:4;77609:14;;;;;;;;:::i;:::-;;;;;;;;;77658;;;:8;:14;;;;;;77673:10;77658:26;;;;;;;;77742:11;;77609:14;;;;;;;77695:12;;77609:14;;-1:-1:-1;77695:59:0;;-1:-1:-1;;;;;77695:12:0;;;;;77673:10;77695:25;:59::i;:::-;77779:1;77765:15;;;77791;;;;:19;-1:-1:-1;;77526:292:0:o;78809:145::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;78912:34;;::::1;::::0;:13:::1;::::0;:34:::1;::::0;::::1;::::0;::::1;:::i;74490:180::-:0;74552:8;:15;74535:14;74578:85;74606:6;74600:3;:12;74578:85;;;74636:15;74647:3;74636:10;:15::i;:::-;74614:5;;;:::i;:::-;;;74578:85;;78409:251;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;78547:3:::1;78529:14;:21;;78484:130;;;::::0;-1:-1:-1;;;78484:130:0;;9855:2:1;78484:130:0::1;::::0;::::1;9837:21:1::0;9894:2;9874:18;;;9867:30;9933:34;9913:18;;;9906:62;-1:-1:-1;;;9984:18:1;;;9977:34;10028:19;;78484:130:0::1;9653:400:1::0;78484:130:0::1;78625:10;:27:::0;78409:251::o;30454:94::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;30519:21:::1;30537:1;30519:9;:21::i;:::-;30454:94::o:0;78272:129::-;78343:7;;-1:-1:-1;;;;;78343:7:0;78329:10;:21;78321:43;;;;-1:-1:-1;;;78321:43:0;;7348:2:1;78321:43:0;;;7330:21:1;7387:1;7367:18;;;7360:29;-1:-1:-1;;;7405:18:1;;;7398:39;7454:18;;78321:43:0;7146:332:1;78321:43:0;78375:7;:18;;-1:-1:-1;;;;;;78375:18:0;-1:-1:-1;;;;;78375:18:0;;;;;;;;;;78272:129::o;69845:23::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69845:23:0;:::o;78968:705::-;79074:14;;:46;;-1:-1:-1;;;79074:46:0;;79012:14;;;;79072:63;;79130:4;;-1:-1:-1;;;;;79074:14:0;;;;:28;;:46;;79103:4;;79109:10;;79074:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;79074:46:0;;;;;;;;;;;;:::i;:::-;79122:1;79073:51;;;;;;;;:::i;:::-;;;;;;;79072:57;;:63;;;;:::i;:::-;79050:85;;79156:15;79174:147;79287:8;79296:1;79287:11;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:19;:33;;;-1:-1:-1;;;79287:33:0;;;;-1:-1:-1;;;;;79287:19:0;;;;:31;;:33;;;;:11;;:33;;;;;:19;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79175:106;79235:8;79244:1;79235:11;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:19;:44;;-1:-1:-1;;;79235:44:0;;79273:4;79235:44;;;4211:51:1;;;;-1:-1:-1;;;;;79235:19:0;;:29;;4184:18:1;;79235:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79177:3;;79199:8;:11;;79176:52;;79226:1;;-1:-1:-1;;;;;79177:3:0;;;;:13;;79199:8;79177:3;;79199:11;;;;:::i;:::-;;;;;;;;;;;;;;:19;79177:43;;;;;;-1:-1:-1;;;;;;79177:43:0;;;-1:-1:-1;;;;;79199:19:0;;;79177:43;;;4211:51:1;;;;4184:18;;79177:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;79174:147::-;79156:165;;79342:11;79356:51;79402:4;79357:39;79373:22;79385:9;;79373:7;:11;;:22;;;;:::i;:::-;79357:11;;:15;:39::i;79356:51::-;79342:65;;79425:9;79420:246;79438:13;:20;79436:22;;79420:246;;;79489:13;79503:1;79489:16;;;;;;;;:::i;:::-;;;;;;;;;79507:4;79489:23;;;;:::i;:::-;79484:3;:29;:63;;;;-1:-1:-1;79522:13:0;79536:3;:1;79538;79536:3;:::i;:::-;79522:18;;;;;;;;:::i;:::-;;;;;;;;;79542:4;79522:25;;;;:::i;:::-;79517:3;:30;;79484:63;79480:175;;;79584:55;79630:8;79585:39;79614:6;79621:1;79614:9;;;;;;;;:::i;:::-;;;;;;;;;79586:22;79598:9;;79586:7;:11;;:22;;;;:::i;79584:55::-;79575:64;;79568:71;;;;78968:705;:::o;79480:175::-;79460:3;;;;:::i;:::-;;;;79420:246;;;;79029:644;;;78968:705;:::o;69911:30::-;;;;;;;;;;;;79685:235;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;79773:17:::1;;79762:7;:28;;79754:56;;;::::0;-1:-1:-1;;;79754:56:0;;8396:2:1;79754:56:0::1;::::0;::::1;8378:21:1::0;8435:2;8415:18;;;8408:30;-1:-1:-1;;;8454:18:1;;;8447:45;8509:18;;79754:56:0::1;8194:339:1::0;79754:56:0::1;79861:7;79841:17;;:27;;;;:::i;:::-;79821:17;:47:::0;79879:3:::1;::::0;:29:::1;::::0;-1:-1:-1;;;79879:29:0;;79888:10:::1;79879:29;::::0;::::1;4827:51:1::0;4894:18;;;4887:34;;;-1:-1:-1;;;;;79879:3:0;;::::1;::::0;:8:::1;::::0;4800:18:1;;79879:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;79685:235:::0;:::o;75894:808::-;75960:21;75984:8;75993:4;75984:14;;;;;;;;:::i;:::-;;;;;;;;;76033;;;:8;:14;;;;;;76048:10;76033:26;;;;;;;75984:14;;;;;;;;-1:-1:-1;76070:16:0;76042:4;76070:10;:16::i;:::-;76101:11;;:15;76097:244;;76163:166;76179:10;76191:123;76298:4;:15;;;76191:88;76274:4;76191:64;76235:4;:19;;;76191:4;:25;;;:43;;:64;;;;:::i;76163:166::-;76365:11;;:24;;76381:7;76365:15;:24::i;:::-;76351:38;;;76434:19;;;;76418:46;;76459:4;;76418:36;;76351:38;76418:15;:36::i;:46::-;76400:15;;;:64;76477:12;;:124;;-1:-1:-1;;;;;76477:12:0;76529:10;76563:4;76583:7;76477:29;:124::i;:::-;76626:4;76634:1;76626:9;76622:73;;;76676:7;76664:9;;:19;;;;:::i;30703:192::-;29849:7;29876:6;-1:-1:-1;;;;;29876:6:0;5592:10;30023:23;30015:68;;;;-1:-1:-1;;;30015:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;30792:22:0;::::1;30784:73;;;::::0;-1:-1:-1;;;30784:73:0;;6941:2:1;30784:73:0::1;::::0;::::1;6923:21:1::0;6980:2;6960:18;;;6953:30;7019:34;6999:18;;;6992:62;-1:-1:-1;;;7070:18:1;;;7063:36;7116:19;;30784:73:0::1;6739:402:1::0;30784:73:0::1;30868:19;30878:8;30868:9;:19::i;:::-;30703:192:::0;:::o;73335:1072::-;73451:18;73497:21;73521:8;73530:4;73521:14;;;;;;;;:::i;:::-;;;;;;;;;73570;;;:8;:14;;;;;;-1:-1:-1;;;;;73570:21:0;;;;;;;;;;73521:14;;;;;;;73627:19;;;;73676:12;;:37;;-1:-1:-1;;;73676:37:0;;73707:4;73676:37;;;4211:51:1;;;;73521:14:0;;-1:-1:-1;73570:21:0;;73627:19;;73521:14;;73676:12;;:22;;4184:18:1;;73676:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73657:56;;73746:4;:24;;;73728:15;:42;:59;;;;-1:-1:-1;73774:13:0;;;73728:59;73724:564;;;73804:18;73825:45;73845:4;:24;;;73825:15;:19;;:45;;;;:::i;:::-;73804:66;;73885:17;73952:10;;73905:26;:57;;;;:::i;:::-;73885:77;;73977:17;73997:162;74154:4;73997:138;74125:9;73997:109;74090:15;;73997:74;74055:4;:15;;;73997:39;74026:9;;73997:10;:28;;:39;;;;:::i;:162::-;73977:182;-1:-1:-1;74191:85:0;74228:33;74252:8;74228:19;73977:182;74242:4;74228:13;:19::i;:33::-;74191:14;;:18;:85::i;:::-;74174:102;;73789:499;;;73724:564;74311:86;74371:4;:15;;;74311:41;74347:4;74311:31;74327:14;74311:4;:11;;;:15;;:31;;;;:::i;:86::-;74298:99;73335:1072;-1:-1:-1;;;;;;;73335:1072:0:o;34165:98::-;34223:7;34250:5;34254:1;34250;:5;:::i;:::-;34243:12;;34165:98;;;;;:::o;33784:::-;33842:7;33869:5;33873:1;33869;:5;:::i;22013:167::-;-1:-1:-1;;;;;22147:23:0;;22093:4;17549:19;;;:12;;;:19;;;;;;:24;;22117:55;17452:129;21441:152;21511:4;21535:50;21540:3;-1:-1:-1;;;;;21560:23:0;;21535:4;:50::i;34522:98::-;34580:7;34607:5;34611:1;34607;:5;:::i;34921:98::-;34979:7;35006:5;35010:1;35006;:5;:::i;77930:286::-;78022:3;;:28;;-1:-1:-1;;;78022:28:0;;78044:4;78022:28;;;4211:51:1;78005:14:0;;-1:-1:-1;;;;;78022:3:0;;:13;;4184:18:1;;78022:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78005:45;;78075:6;78065:7;:16;78061:148;;;78098:3;;78127:9;;-1:-1:-1;;;;;78098:3:0;;;;:12;;78111:3;;78116:21;;:6;;:10;:21::i;:::-;78098:40;;-1:-1:-1;;;;;;78098:40:0;;;;;;;-1:-1:-1;;;;;4845:32:1;;;78098:40:0;;;4827:51:1;4894:18;;;4887:34;4800:18;;78098:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;78061:148::-;78171:3;;:26;;-1:-1:-1;;;78171:26:0;;-1:-1:-1;;;;;4845:32:1;;;78171:26:0;;;4827:51:1;4894:18;;;4887:34;;;78171:3:0;;;;:12;;4800:18:1;;78171:26:0;4653:274:1;57009:401:0;57197:48;;;-1:-1:-1;;;;;4845:32:1;;;57197:48:0;;;4827:51:1;4894:18;;;;4887:34;;;57197:48:0;;;;;;;;;;4800:18:1;;;;57197:48:0;;;;;;;-1:-1:-1;;;;;57197:48:0;-1:-1:-1;;;57197:48:0;;;57163:93;;-1:-1:-1;;;;57163:19:0;;;;:93;;57197:48;57163:93;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57127:129;;;;57289:7;:57;;;;-1:-1:-1;57301:11:0;;:16;;:44;;;57332:4;57321:24;;;;;;;;;;;;:::i;:::-;57267:135;;;;-1:-1:-1;;;57267:135:0;;6584:2:1;57267:135:0;;;6566:21:1;6623:2;6603:18;;;6596:30;6662;6642:18;;;6635:58;6710:18;;57267:135:0;6382:352:1;30903:173:0;30959:16;30978:6;;-1:-1:-1;;;;;30995:17:0;;;-1:-1:-1;;;;;;30995:17:0;;;;;;31028:40;;30978:6;;;;;;;31028:40;;30959:16;31028:40;30948:128;30903:173;:::o;57733:443::-;57948:59;;;-1:-1:-1;;;;;4531:15:1;;;57948:59:0;;;4513:34:1;4583:15;;;4563:18;;;4556:43;4615:18;;;;4608:34;;;57948:59:0;;;;;;;;;;4448:18:1;;;;57948:59:0;;;;;;;-1:-1:-1;;;;;57948:59:0;-1:-1:-1;;;57948:59:0;;;57914:104;;-1:-1:-1;;;;57914:19:0;;;;:104;;57948:59;57914:104;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57878:140;;;;58051:7;:57;;;;-1:-1:-1;58063:11:0;;:16;;:44;;;58094:4;58083:24;;;;;;;;;;;;:::i;:::-;58029:139;;;;-1:-1:-1;;;58029:139:0;;9494:2:1;58029:139:0;;;9476:21:1;;;9513:18;;;9506:30;9572:34;9552:18;;;9545:62;9624:18;;58029:139:0;9292:356:1;58029:139:0;57867:309;;57733:443;;;;:::o;15356:414::-;15419:4;17549:19;;;:12;;;:19;;;;;;15436:327;;-1:-1:-1;15479:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;15662:18;;15640:19;;;:12;;;:19;;;;;;:40;;;;15695:11;;15436:327;-1:-1:-1;15746:5:0;15739:12;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:247:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;:::-;250:5;14:247;-1:-1:-1;;;14:247:1:o;266:902::-;350:6;381:2;424;412:9;403:7;399:23;395:32;392:52;;;440:1;437;430:12;392:52;480:9;467:23;513:18;505:6;502:30;499:50;;;545:1;542;535:12;499:50;568:22;;621:4;613:13;;609:27;-1:-1:-1;599:55:1;;650:1;647;640:12;599:55;686:2;673:16;709:60;725:43;765:2;725:43;:::i;:::-;709:60;:::i;:::-;791:3;815:2;810:3;803:15;843:2;838:3;834:12;827:19;;874:2;870;866:11;922:7;917:2;911;908:1;904:10;900:2;896:19;892:28;889:41;886:61;;;943:1;940;933:12;886:61;965:1;956:10;;975:163;989:2;986:1;983:9;975:163;;;1046:17;;1034:30;;1007:1;1000:9;;;;;1084:12;;;;1116;;975:163;;;-1:-1:-1;1157:5:1;266:902;-1:-1:-1;;;;;;;266:902:1:o;1173:892::-;1268:6;1299:2;1342;1330:9;1321:7;1317:23;1313:32;1310:52;;;1358:1;1355;1348:12;1310:52;1391:9;1385:16;1424:18;1416:6;1413:30;1410:50;;;1456:1;1453;1446:12;1410:50;1479:22;;1532:4;1524:13;;1520:27;-1:-1:-1;1510:55:1;;1561:1;1558;1551:12;1510:55;1590:2;1584:9;1613:60;1629:43;1669:2;1629:43;:::i;1613:60::-;1695:3;1719:2;1714:3;1707:15;1747:2;1742:3;1738:12;1731:19;;1778:2;1774;1770:11;1826:7;1821:2;1815;1812:1;1808:10;1804:2;1800:19;1796:28;1793:41;1790:61;;;1847:1;1844;1837:12;1790:61;1869:1;1860:10;;1879:156;1893:2;1890:1;1887:9;1879:156;;;1950:10;;1938:23;;1911:1;1904:9;;;;;1981:12;;;;2013;;1879:156;;2070:277;2137:6;2190:2;2178:9;2169:7;2165:23;2161:32;2158:52;;;2206:1;2203;2196:12;2158:52;2238:9;2232:16;2291:5;2284:13;2277:21;2270:5;2267:32;2257:60;;2313:1;2310;2303:12;2352:180;2411:6;2464:2;2452:9;2443:7;2439:23;2435:32;2432:52;;;2480:1;2477;2470:12;2432:52;-1:-1:-1;2503:23:1;;2352:180;-1:-1:-1;2352:180:1:o;2537:184::-;2607:6;2660:2;2648:9;2639:7;2635:23;2631:32;2628:52;;;2676:1;2673;2666:12;2628:52;-1:-1:-1;2699:16:1;;2537:184;-1:-1:-1;2537:184:1:o;2726:315::-;2794:6;2802;2855:2;2843:9;2834:7;2830:23;2826:32;2823:52;;;2871:1;2868;2861:12;2823:52;2907:9;2894:23;2884:33;;2967:2;2956:9;2952:18;2939:32;2980:31;3005:5;2980:31;:::i;:::-;3030:5;3020:15;;;2726:315;;;;;:::o;3381:248::-;3449:6;3457;3510:2;3498:9;3489:7;3485:23;3481:32;3478:52;;;3526:1;3523;3516:12;3478:52;-1:-1:-1;;3549:23:1;;;3619:2;3604:18;;;3591:32;;-1:-1:-1;3381:248:1:o;3634:426::-;3763:3;3801:6;3795:13;3826:1;3836:129;3850:6;3847:1;3844:13;3836:129;;;3948:4;3932:14;;;3928:25;;3922:32;3909:11;;;3902:53;3865:12;3836:129;;;3983:6;3980:1;3977:13;3974:48;;;4018:1;4009:6;4004:3;4000:16;3993:27;3974:48;-1:-1:-1;4038:16:1;;;;;3634:426;-1:-1:-1;;3634:426:1:o;5599:778::-;5792:4;5840:2;5829:9;5825:18;5870:6;5859:9;5852:25;5896:2;5934;5929;5918:9;5914:18;5907:30;5957:6;5992;5986:13;6023:6;6015;6008:22;6061:2;6050:9;6046:18;6039:25;;6083:6;6080:1;6073:17;6126:2;6123:1;6113:16;6099:30;;6147:1;6157:194;6171:6;6168:1;6165:13;6157:194;;;6236:13;;-1:-1:-1;;;;;6232:39:1;6220:52;;6268:1;6327:14;;;;6292:12;;;;6186:9;6157:194;;;-1:-1:-1;6368:3:1;;5599:778;-1:-1:-1;;;;;;;5599:778:1:o;7833:356::-;8035:2;8017:21;;;8054:18;;;8047:30;8113:34;8108:2;8093:18;;8086:62;8180:2;8165:18;;7833:356::o;10493:275::-;10564:2;10558:9;10629:2;10610:13;;-1:-1:-1;;10606:27:1;10594:40;;10664:18;10649:34;;10685:22;;;10646:62;10643:88;;;10711:18;;:::i;:::-;10747:2;10740:22;10493:275;;-1:-1:-1;10493:275:1:o;10773:183::-;10833:4;10866:18;10858:6;10855:30;10852:56;;;10888:18;;:::i;:::-;-1:-1:-1;10933:1:1;10929:14;10945:4;10925:25;;10773:183::o;10961:128::-;11001:3;11032:1;11028:6;11025:1;11022:13;11019:39;;;11038:18;;:::i;:::-;-1:-1:-1;11074:9:1;;10961:128::o;11094:217::-;11134:1;11160;11150:132;;11204:10;11199:3;11195:20;11192:1;11185:31;11239:4;11236:1;11229:15;11267:4;11264:1;11257:15;11150:132;-1:-1:-1;11296:9:1;;11094:217::o;11316:168::-;11356:7;11422:1;11418;11414:6;11410:14;11407:1;11404:21;11399:1;11392:9;11385:17;11381:45;11378:71;;;11429:18;;:::i;:::-;-1:-1:-1;11469:9:1;;11316:168::o;11489:125::-;11529:4;11557:1;11554;11551:8;11548:34;;;11562:18;;:::i;:::-;-1:-1:-1;11599:9:1;;11489:125::o;11619:135::-;11658:3;-1:-1:-1;;11679:17:1;;11676:43;;;11699:18;;:::i;:::-;-1:-1:-1;11746:1:1;11735:13;;11619:135::o;11759:127::-;11820:10;11815:3;11811:20;11808:1;11801:31;11851:4;11848:1;11841:15;11875:4;11872:1;11865:15;11891:127;11952:10;11947:3;11943:20;11940:1;11933:31;11983:4;11980:1;11973:15;12007:4;12004:1;11997:15;12023:127;12084:10;12079:3;12075:20;12072:1;12065:31;12115:4;12112:1;12105:15;12139:4;12136:1;12129:15;12155:131;-1:-1:-1;;;;;12230:31:1;;12220:42;;12210:70;;12276:1;12273;12266:12
Swarm Source
ipfs://65ac19dba01bbb00a0c0d8c1adc3cbffe70225c379c84aadb439820180f0b9fc
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ 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.