Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x61014060 | 20182574 | 27 days ago | IN | Create: FiasPrivateVesting | 0 ETH | 0.01227407 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
FiasPrivateVesting
Compiler Version
v0.8.25+commit.b61c2a91
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-06-27 */ /** *Submitted for verification at Etherscan.io on 2024-06-27 */ /** *Submitted for verification at Etherscan.io on 2024-06-11 */ pragma solidity ^0.8.12; interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval( address indexed owner, address indexed spender, uint256 value ); } library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } else if (error == RecoverError.InvalidSignatureV) { revert("ECDSA: invalid signature 'v' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { // Check the signature length // - case 65: r,s,v signature (standard) // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._ if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else if (signature.length == 64) { bytes32 r; bytes32 vs; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) vs := mload(add(signature, 0x40)) } return tryRecover(hash, r, vs); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32( 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if ( uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 ) { return (address(0), RecoverError.InvalidSignatureS); } if (v != 27 && v != 28) { return (address(0), RecoverError.InvalidSignatureV); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256( abi.encodePacked("\x19Ethereum Signed Message:\n32", hash) ); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256( abi.encodePacked( "\x19Ethereum Signed Message:\n", Strings.toString(s.length), s ) ); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256( abi.encodePacked("\x19\x01", domainSeparator, structHash) ); } } library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or 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 { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; address private immutable _CACHED_THIS; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator( typeHash, hashedName, hashedVersion ); _CACHED_THIS = address(this); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if ( address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID ) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator( _TYPE_HASH, _HASHED_NAME, _HASHED_VERSION ); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 nameHash, bytes32 versionHash ) private view returns (bytes32) { return keccak256( abi.encode( typeHash, nameHash, versionHash, block.chainid, address(this) ) ); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } } abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Internal function that returns the initialized version. Returns `_initialized` */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Internal function that returns the initialized version. Returns `_initializing` */ function _isInitializing() internal view returns (bool) { return _initializing; } } abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ // function renounceOwnership() public virtual onlyOwner { // _transferOwnership(address(0)); // } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) internal virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } interface IERC20PermitUpgradeable { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } interface IERC20Upgradeable { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.8.12; contract whitelistChecker is EIP712 { string private constant SIGNING_DOMAIN = "DevvE_LAUNCHPAD"; string private constant SIGNATURE_VERSION = "1"; struct Signer { address userAddress; address contractAddress; uint256 id; uint256 timestamp; bytes signature; } constructor() EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {} function getSigner(Signer memory whitelist) public view returns (address) { return _verify(whitelist); } /// @notice Returns a hash of the given whitelist, prepared using EIP712 typed data hashing rules. function _hash(Signer memory whitelist) internal view returns (bytes32) { return _hashTypedDataV4( keccak256( abi.encode( keccak256( "Signer(address userAddress,address contractAddress,uint256 id,uint256 timestamp)" ), whitelist.userAddress, whitelist.contractAddress, whitelist.id, whitelist.timestamp ) ) ); } function _verify(Signer memory whitelist) internal view returns (address) { bytes32 digest = _hash(whitelist); return ECDSA.recover(digest, whitelist.signature); } } library SafeERC20Upgradeable { using AddressUpgradeable for address; function safeTransfer( IERC20Upgradeable token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20Upgradeable 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( IERC20Upgradeable 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( IERC20Upgradeable 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( IERC20Upgradeable 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)); } } function safePermit( IERC20PermitUpgradeable token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @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(IERC20Upgradeable 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"); } } } contract FiasPrivateVesting is OwnableUpgradeable, whitelistChecker ,ReentrancyGuardUpgradeable{ using SafeERC20Upgradeable for IERC20Upgradeable; IERC20Upgradeable public token; address public signer; bool private isStart; bool private iscollect; bool private ischeck; uint256 public activeLockDate; uint256 public totalDepositTokens; uint256 public totalAllocatedamount; uint256 public totalAirdropAllocationamount; uint256 public vestingEndTime; mapping(address=>mapping(uint=>bool)) public usedNonce; mapping (address => bool) public isUserAdded; mapping (address => bool) public isAirdropUserAdded; mapping(address => InvestorDetails) public Investors; address private pendingOwner; uint256 day; event TokenWithdraw(address indexed buyer, uint256 value,uint256 id); event RecoverToken(address indexed token, uint256 indexed amount); event RemoveUser(address _userAddress); event InvestorAddress(address account, uint256 _amout); event startDate(uint256 date); event setTokens(address _userAddress); event OwnershipTransferInitiated(address indexed currentOwner, address indexed pendingOwner); modifier setDate() { require(isStart == true, "wait for start date"); _; } modifier _iscollect() { require(iscollect == true, "wait"); _; } modifier check() { require(ischeck == true); _; } uint256 public TGEStartDate; uint256 public lockEndDate; uint256 public totalLinearUnits; uint256 public initialPercentage; uint256 public intermediaryPercentage; uint256 public intermediateTime; uint256 private middleTime; uint256 private linearTime; uint256 vestingPeriodDays = 12 * 30; // 12 months * 30 days receive() external payable {} function getInvestorDetails(address _addr)public view returns (InvestorDetails memory) { return Investors[_addr]; } function getContractTokenBalance() public view returns (uint256) { return token.balanceOf(address(this)); } function setSigner(address _addr) public onlyOwner { signer = _addr; } function remainningTokens() external view returns (uint256) { return totalDepositTokens - totalAllocatedamount; } struct Investor { address account; uint256 amount; } struct InvestorDetails { uint256 totalBalance; uint256 timeDifference; uint256 lastVestedTime; uint256 reminingUnitsToVest; uint256 tokensPerUnit; uint256 vestingBalance; uint256 lastWithdrawalTimestamp; uint256 initialAmount; uint256 nextAmount; bool isInitialAmountClaimed; } // Adds details of a new investor function addInvestorDetails(uint amount, Signer memory _signer ) public nonReentrant{ require(!usedNonce[msg.sender][_signer.timestamp],"Nonce : Invalid Nonce"); require(getSigner(_signer) == signer, "Invalid Signer"); require (!isUserAdded[msg.sender],'User already added'); usedNonce[msg.sender][_signer.timestamp]=true; isUserAdded[msg.sender] = true; InvestorDetails memory investor; investor.totalBalance = amount; investor.vestingBalance = investor.totalBalance; investor.reminingUnitsToVest = totalLinearUnits; investor.initialAmount =((investor.totalBalance) * (initialPercentage)) /100; investor.nextAmount =((investor.totalBalance) * (intermediaryPercentage)) /100; investor.tokensPerUnit = ((investor.totalBalance) - (investor.initialAmount) - (investor.nextAmount)) /totalLinearUnits; if(investor.initialAmount == 0 && investor.nextAmount == 0){ investor.isInitialAmountClaimed = true; } Investors[_signer.userAddress] = investor; totalAllocatedamount += investor.totalBalance; emit InvestorAddress(msg.sender,amount); } // Allows the admin to add multiple investors function addInvestorsbyadmin(Investor[] memory vest) external onlyOwner nonReentrant{ require(vest.length<=50,"Max Length Reached"); for (uint i = 0;i < vest.length;i++) { require (!isUserAdded[vest[i].account],'User already added'); isUserAdded[vest[i].account] = true; InvestorDetails memory investor; investor.totalBalance = vest[i].amount; investor.vestingBalance = investor.totalBalance; investor.reminingUnitsToVest = totalLinearUnits; investor.initialAmount =((investor.totalBalance) * (initialPercentage)) /100; investor.nextAmount =((investor.totalBalance) * (intermediaryPercentage)) /100; investor.tokensPerUnit = ((investor.totalBalance) - (investor.initialAmount) - (investor.nextAmount)) /totalLinearUnits; if(investor.initialAmount == 0 && investor.nextAmount == 0){ investor.isInitialAmountClaimed = true; } Investors[vest[i].account] = investor; totalAllocatedamount += investor.totalBalance; emit InvestorAddress(vest[i].account,vest[i].amount); } } // Removes a single user from a specific project. function removeSingleUser(address _userAddress)public onlyOwner{ require(isUserAdded[_userAddress],"Not a Investor"); delete Investors[_userAddress]; isUserAdded[_userAddress]=false; emit RemoveUser(_userAddress); } //Allows the withdrawal of a specified amount of tokens from the contract. function withdrawTokenfunction(Signer memory _signer) external nonReentrant{ require(isStart = true, "wait for start date"); require(block.timestamp >= TGEStartDate, "TGE has not started yet"); require(!usedNonce[msg.sender][_signer.timestamp],"Nonce : Invalid Nonce"); require(getSigner(_signer) == signer, "Invalid Signer"); usedNonce[msg.sender][_signer.timestamp]=true; uint256 id = 1; uint256 lineartoken = withdrawTokens(); uint256 totaltokens = lineartoken;// airdroptoekns + lineartoken; require(totaltokens > 0, "wait for start date"); token.safeTransfer(msg.sender, totaltokens); emit TokenWithdraw(msg.sender, totaltokens,id); } function withdrawTokens() internal setDate returns (uint256) { if (block.timestamp >= lockEndDate) { activeLockDate = lockEndDate; /* Time difference to calculate the interval between now and last vested time. */ uint256 timeDifference; if (Investors[msg.sender].lastVestedTime == 0) { if (activeLockDate == 0) { return 0; // Active lockdate was zero } timeDifference = block.timestamp - activeLockDate; } else { timeDifference = block.timestamp - Investors[msg.sender].lastVestedTime; } uint256 numberOfUnitsCanBeVested = timeDifference / day; /* Remaining units to vest should be greater than 0 */ if (Investors[msg.sender].reminingUnitsToVest == 0) { return 0; // All units vested! } /* Number of units can be vested should be more than 0 */ if (numberOfUnitsCanBeVested == 0) { return 0; // Please wait till next vesting period! } if ( numberOfUnitsCanBeVested >= Investors[msg.sender].reminingUnitsToVest ) { numberOfUnitsCanBeVested = Investors[msg.sender] .reminingUnitsToVest; } uint256 tokenToTransfer = numberOfUnitsCanBeVested * Investors[msg.sender].tokensPerUnit; uint256 remainingUnits = Investors[msg.sender] .reminingUnitsToVest; uint256 balance = Investors[msg.sender].vestingBalance; Investors[msg.sender] .reminingUnitsToVest -= numberOfUnitsCanBeVested; Investors[msg.sender].vestingBalance -= numberOfUnitsCanBeVested * Investors[msg.sender].tokensPerUnit; Investors[msg.sender].lastVestedTime = block.timestamp; Investors[msg.sender].lastWithdrawalTimestamp = block.timestamp; bool isInitialAmountClaimed = Investors[msg.sender].isInitialAmountClaimed; if (numberOfUnitsCanBeVested == remainingUnits) { if(isInitialAmountClaimed==true){ return balance; }else{ uint256 totalamount = Investors[msg.sender].nextAmount +balance; Investors[msg.sender].isInitialAmountClaimed = true; Investors[msg.sender].vestingBalance -= Investors[msg.sender].nextAmount + Investors[msg.sender].initialAmount; return totalamount; } } else { if(isInitialAmountClaimed==true){ return tokenToTransfer; }else{ uint256 totalamount = Investors[msg.sender].nextAmount +tokenToTransfer; Investors[msg.sender].isInitialAmountClaimed = true; Investors[msg.sender].vestingBalance -= Investors[msg.sender].nextAmount + Investors[msg.sender].initialAmount; return totalamount; } } } else { return 0; // Wait until lock period completes } } // Allows the deposit of a specified amount of tokens into the contract. function depositToken(uint256 amount) public { token.safeTransferFrom(msg.sender, address(this), amount); totalDepositTokens += amount; } function recoverTokens(address _token,address _userAddress,uint256 amount) public onlyOwner { IERC20Upgradeable(_token).transfer(_userAddress, amount); emit RecoverToken(_token, amount); } function getAvailableBalance(address _addr)public view returns (uint256,uint256,uint256) { // if (Investors[_addr].isInitialAmountClaimed) { if (block.timestamp >= lockEndDate) { uint256 lockDate = lockEndDate; uint256 hello = day; uint256 timeDifference; if (Investors[_addr].lastVestedTime == 0) { if(lockEndDate == 0) return (0, 0, 0); timeDifference = (block.timestamp) - (lockDate); } else { timeDifference =(block.timestamp) - (Investors[_addr].lastVestedTime); } if (Investors[_addr].reminingUnitsToVest == 0) { return (0, 0, 0); // All units vested! } uint256 numberOfUnitsCanBeVested; uint256 tokenToTransfer; numberOfUnitsCanBeVested = (timeDifference) / (hello); if (numberOfUnitsCanBeVested >= Investors[_addr].reminingUnitsToVest) { numberOfUnitsCanBeVested = Investors[_addr].reminingUnitsToVest; } tokenToTransfer = numberOfUnitsCanBeVested * Investors[_addr].tokensPerUnit; uint256 reminingUnits = Investors[_addr].reminingUnitsToVest; uint256 balance = Investors[_addr].vestingBalance; bool isInitialAmountClaimed = Investors[_addr].isInitialAmountClaimed; if (numberOfUnitsCanBeVested == reminingUnits) if(isInitialAmountClaimed==true){ return (balance, 0, 0); }else{ uint256 totalamount = Investors[_addr].nextAmount + balance; return (totalamount, 0, 0); } else { if(isInitialAmountClaimed==true){ return (tokenToTransfer, reminingUnits, balance); }else{ uint256 totalamount = Investors[_addr].nextAmount + tokenToTransfer; return (totalamount, 0, 0); } } }else{ return (0, 0, 0); } } //Sets the vesting start date function setStartDate(uint256 _startDate) external onlyOwner { TGEStartDate = _startDate; intermediateTime = _startDate + middleTime * 1 days; lockEndDate = intermediateTime + linearTime * 1 days; vestingEndTime = lockEndDate + totalLinearUnits * day; emit startDate (_startDate); } //Sets the address of the ERC-20 token contract to be used by the platform. function setToken(address _token) external onlyOwner { require(_token != address(0), "Invalid Token Address"); token = IERC20Upgradeable(_token); emit setTokens (_token); } function initialize(address Signer,uint256 _totalLinearUnits,uint256 timeBetweenUnits, uint256 linearStartDate, uint256 _startDate, address _tokenAddress, uint256 _initialPercentage, uint256 _intermediatePercentage, uint256 _intermediateTime) external initializer{ require(_tokenAddress != address(0)); middleTime = _intermediateTime; linearTime = linearStartDate; token = IERC20Upgradeable(_tokenAddress); totalLinearUnits = _totalLinearUnits; day = timeBetweenUnits * 1 days; TGEStartDate = _startDate; initialPercentage = _initialPercentage; intermediaryPercentage = _intermediatePercentage; intermediateTime = _startDate + middleTime * 1 days; lockEndDate = intermediateTime + linearTime * 1 days; isStart = true; signer = Signer; vestingEndTime = lockEndDate + _totalLinearUnits * timeBetweenUnits * 1 days; __Ownable_init(); __ReentrancyGuard_init(); } modifier onlyPendingOwner() { require(msg.sender == pendingOwner, "Caller is not the pending owner"); _; } // Function to initiate ownership transfer function initiateOwnershipTransfer(address newOwner) external onlyOwner { require(newOwner != address(0), "Invalid Wallet Address"); pendingOwner = newOwner; emit OwnershipTransferInitiated(owner(), pendingOwner); } // Function to confirm ownership transfer function confirmOwnershipTransfer() external onlyPendingOwner { _transferOwnership(pendingOwner); pendingOwner = address(0); // Reset pending owner } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amout","type":"uint256"}],"name":"InvestorAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"currentOwner","type":"address"},{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipTransferInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoverToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_userAddress","type":"address"}],"name":"RemoveUser","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"TokenWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_userAddress","type":"address"}],"name":"setTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"date","type":"uint256"}],"name":"startDate","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Investors","outputs":[{"internalType":"uint256","name":"totalBalance","type":"uint256"},{"internalType":"uint256","name":"timeDifference","type":"uint256"},{"internalType":"uint256","name":"lastVestedTime","type":"uint256"},{"internalType":"uint256","name":"reminingUnitsToVest","type":"uint256"},{"internalType":"uint256","name":"tokensPerUnit","type":"uint256"},{"internalType":"uint256","name":"vestingBalance","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawalTimestamp","type":"uint256"},{"internalType":"uint256","name":"initialAmount","type":"uint256"},{"internalType":"uint256","name":"nextAmount","type":"uint256"},{"internalType":"bool","name":"isInitialAmountClaimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TGEStartDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeLockDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"_signer","type":"tuple"}],"name":"addInvestorDetails","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct FiasPrivateVesting.Investor[]","name":"vest","type":"tuple[]"}],"name":"addInvestorsbyadmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"confirmOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getAvailableBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getContractTokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getInvestorDetails","outputs":[{"components":[{"internalType":"uint256","name":"totalBalance","type":"uint256"},{"internalType":"uint256","name":"timeDifference","type":"uint256"},{"internalType":"uint256","name":"lastVestedTime","type":"uint256"},{"internalType":"uint256","name":"reminingUnitsToVest","type":"uint256"},{"internalType":"uint256","name":"tokensPerUnit","type":"uint256"},{"internalType":"uint256","name":"vestingBalance","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawalTimestamp","type":"uint256"},{"internalType":"uint256","name":"initialAmount","type":"uint256"},{"internalType":"uint256","name":"nextAmount","type":"uint256"},{"internalType":"bool","name":"isInitialAmountClaimed","type":"bool"}],"internalType":"struct FiasPrivateVesting.InvestorDetails","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"whitelist","type":"tuple"}],"name":"getSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"Signer","type":"address"},{"internalType":"uint256","name":"_totalLinearUnits","type":"uint256"},{"internalType":"uint256","name":"timeBetweenUnits","type":"uint256"},{"internalType":"uint256","name":"linearStartDate","type":"uint256"},{"internalType":"uint256","name":"_startDate","type":"uint256"},{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_initialPercentage","type":"uint256"},{"internalType":"uint256","name":"_intermediatePercentage","type":"uint256"},{"internalType":"uint256","name":"_intermediateTime","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"initiateOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"intermediaryPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"intermediateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isAirdropUserAdded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isUserAdded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockEndDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"remainningTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"}],"name":"removeSingleUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startDate","type":"uint256"}],"name":"setStartDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAirdropAllocationamount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocatedamount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDepositTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLinearUnits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"usedNonce","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"_signer","type":"tuple"}],"name":"withdrawTokenfunction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
46105:15260:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46728:51;;;;;;;;;;-1:-1:-1;46728:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;644:14:1;;637:22;619:41;;607:2;592:18;46728:51:0;;;;;;;;46486:35;;;;;;;;;;;;;;;;;;;817:25:1;;;805:2;790:18;46486:35:0;671:177:1;46677:44:0;;;;;;;;;;-1:-1:-1;46677:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;59428:204;;;;;;;;;;-1:-1:-1;59428:204:0;;;;;:::i;:::-;;:::i;:::-;;46299:21;;;;;;;;;;-1:-1:-1;46299:21:0;;;;-1:-1:-1;;;;;46299:21:0;;;;;;-1:-1:-1;;;;;1017:32:1;;;999:51;;987:2;972:18;46299:21:0;853:203:1;48145:121:0;;;;;;;;;;;;;:::i;47798:31::-;;;;;;;;;;;;;;;;51870:743;;;;;;;;;;-1:-1:-1;51870:743:0;;;;;:::i;:::-;;:::i;48366:127::-;;;;;;;;;;;;;:::i;46528:43::-;;;;;;;;;;;;;;;;59638:1062;;;;;;;;;;-1:-1:-1;59638:1062:0;;;;;:::i;:::-;;:::i;41120:118::-;;;;;;;;;;-1:-1:-1;41120:118:0;;;;;:::i;:::-;;:::i;56508:211::-;;;;;;;;;;-1:-1:-1;56508:211:0;;;;;:::i;:::-;;:::i;56342:160::-;;;;;;;;;;-1:-1:-1;56342:160:0;;;;;:::i;:::-;;:::i;48274:84::-;;;;;;;;;;-1:-1:-1;48274:84:0;;;;;:::i;:::-;;:::i;56725:2242::-;;;;;;;;;;-1:-1:-1;56725:2242:0;;;;;:::i;:::-;;:::i;:::-;;;;4869:25:1;;;4925:2;4910:18;;4903:34;;;;4953:18;;;4946:34;4857:2;4842:18;56725:2242:0;4667:319:1;61190:172:0;;;;;;;;;;;;;:::i;47644:26::-;;;;;;;;;;;;;;;;59008:333;;;;;;;;;;-1:-1:-1;59008:333:0;;;;;:::i;:::-;;:::i;51528:256::-;;;;;;;;;;-1:-1:-1;51528:256:0;;;;;:::i;:::-;;:::i;46578:29::-;;;;;;;;;;;;;;;;32061:87;;;;;;;;;;-1:-1:-1;32134:6:0;;-1:-1:-1;;;;;32134:6:0;32061:87;;47610:27;;;;;;;;;;;;;;;;47677:31;;;;;;;;;;;;;;;;46446:33;;;;;;;;;;;;;;;;46410:29;;;;;;;;;;;;;;;;47715:32;;;;;;;;;;;;;;;;50267:1199;;;;;;;;;;-1:-1:-1;50267:1199:0;;;;;:::i;:::-;;:::i;49006:1204::-;;;;;;;;;;-1:-1:-1;49006:1204:0;;;;;:::i;:::-;;:::i;60890:247::-;;;;;;;;;;-1:-1:-1;60890:247:0;;;;;:::i;:::-;;:::i;47754:37::-;;;;;;;;;;;;;;;;46786:52;;;;;;;;;;-1:-1:-1;46786:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6977:25:1;;;7033:2;7018:18;;7011:34;;;;7061:18;;;7054:34;;;;7119:2;7104:18;;7097:34;;;;7162:3;7147:19;;7140:35;;;;7206:3;7191:19;;7184:35;7250:3;7235:19;;7228:35;7294:3;7279:19;;7272:35;7338:3;7323:19;;7316:35;7395:14;7388:22;7382:3;7367:19;;7360:51;6964:3;6949:19;46786:52:0;6584:833:1;48008:129:0;;;;;;;;;;-1:-1:-1;48008:129:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;46616:54::-;;;;;;;;;;-1:-1:-1;46616:54:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;46262:30;;;;;;;;;;-1:-1:-1;46262:30:0;;;;-1:-1:-1;;;;;46262:30:0;;;59428:204;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;59500:20:0;::::1;59492:54;;;::::0;-1:-1:-1;;;59492:54:0;;9393:2:1;59492:54:0::1;::::0;::::1;9375:21:1::0;9432:2;9412:18;;;9405:30;-1:-1:-1;;;9451:18:1;;;9444:51;9512:18;;59492:54:0::1;9191:345:1::0;59492:54:0::1;59557:5;:33:::0;;-1:-1:-1;;;;;;59557:33:0::1;-1:-1:-1::0;;;;;59557:33:0;::::1;::::0;;::::1;::::0;;;59606:18:::1;::::0;999:51:1;;;59606:18:0::1;::::0;987:2:1;972:18;59606::0::1;;;;;;;;59428:204:::0;:::o;48145:121::-;48228:5;;:30;;-1:-1:-1;;;48228:30:0;;48252:4;48228:30;;;999:51:1;48201:7:0;;-1:-1:-1;;;;;48228:5:0;;:15;;972:18:1;;48228:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48221:37;;48145:121;:::o;51870:743::-;35454:21;:19;:21::i;:::-;51964:7:::1;:14:::0;;-1:-1:-1;;;;51964:14:0::1;-1:-1:-1::0;;;51964:14:0::1;::::0;;52040:12:::1;;52021:15;:31;;52013:67;;;::::0;-1:-1:-1;;;52013:67:0;;10280:2:1;52013:67:0::1;::::0;::::1;10262:21:1::0;10319:2;10299:18;;;10292:30;10358:25;10338:18;;;10331:53;10401:18;;52013:67:0::1;10078:347:1::0;52013:67:0::1;52110:10;52100:21;::::0;;;:9:::1;:21;::::0;;;;;;;52122:17:::1;::::0;::::1;::::0;52100:40;;;;;;;;::::1;;52099:41;52091:74;;;::::0;-1:-1:-1;;;52091:74:0;;10632:2:1;52091:74:0::1;::::0;::::1;10614:21:1::0;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:51;10751:18;;52091:74:0::1;10430:345:1::0;52091:74:0::1;52206:6;::::0;-1:-1:-1;;;;;52206:6:0::1;52184:18;52194:7:::0;52184:9:::1;:18::i;:::-;-1:-1:-1::0;;;;;52184:28:0::1;;52176:55;;;::::0;-1:-1:-1;;;52176:55:0;;10982:2:1;52176:55:0::1;::::0;::::1;10964:21:1::0;11021:2;11001:18;;;10994:30;-1:-1:-1;;;11040:18:1;;;11033:44;11094:18;;52176:55:0::1;10780:338:1::0;52176:55:0::1;52252:10;52242:21;::::0;;;:9:::1;:21;::::0;;;;;;;52264:17:::1;::::0;::::1;::::0;52242:40;;;;;;;:45;;-1:-1:-1;;52242:45:0::1;52283:4;52242:45:::0;;::::1;::::0;;;52283:4;52345:16:::1;:14;:16::i;:::-;52323:38:::0;-1:-1:-1;52323:38:0;52455:15;52447:47:::1;;;::::0;-1:-1:-1;;;52447:47:0;;9932:2:1;52447:47:0::1;::::0;::::1;9914:21:1::0;9971:2;9951:18;;;9944:30;-1:-1:-1;;;9990:18:1;;;9983:49;10049:18;;52447:47:0::1;9730:343:1::0;52447:47:0::1;52505:5;::::0;:43:::1;::::0;-1:-1:-1;;;;;52505:5:0::1;52524:10;52536:11:::0;52505:18:::1;:43::i;:::-;52564:41;::::0;;11297:25:1;;;11353:2;11338:18;;11331:34;;;52578:10:0::1;::::0;52564:41:::1;::::0;11270:18:1;52564:41:0::1;;;;;;;51945:668;;;35498:20:::0;34715:1;36018:7;:22;35835:213;35498:20;51870:743;:::o;48366:127::-;48417:7;48465:20;;48444:18;;:41;;;;:::i;59638:1062::-;27298:19;27321:13;;;;;;27320:14;;27368:34;;;;-1:-1:-1;27386:12:0;;27401:1;27386:12;;;;:16;27368:34;27367:108;;;-1:-1:-1;27447:4:0;15728:19;:23;;;27408:66;;-1:-1:-1;27457:12:0;;;;;:17;27408:66;27345:204;;;;-1:-1:-1;;;27345:204:0;;11843:2:1;27345:204:0;;;11825:21:1;11882:2;11862:18;;;11855:30;11921:34;11901:18;;;11894:62;-1:-1:-1;;;11972:18:1;;;11965:44;12026:19;;27345:204:0;11641:410:1;27345:204:0;27560:12;:16;;-1:-1:-1;;27560:16:0;27575:1;27560:16;;;27587:67;;;;27622:13;:20;;-1:-1:-1;;27622:20:0;;;;;27587:67;-1:-1:-1;;;;;59974:27:0;::::1;59966:36;;;::::0;::::1;;60013:10;:30:::0;;;60054:10:::1;:28:::0;;;60093:5:::1;:40:::0;;-1:-1:-1;;;;;;60093:40:0::1;-1:-1:-1::0;;;;;60093:40:0;::::1;;::::0;;60144:16:::1;:36:::0;;;60197:25:::1;:16:::0;60216:6:::1;60197:25;:::i;:::-;60191:3;:31:::0;60233:12:::1;:25:::0;;;60269:17:::1;:38:::0;;;60318:22:::1;:48:::0;;;60409:10:::1;::::0;:19:::1;::::0;60422:6:::1;60409:19;:::i;:::-;60396:32;::::0;:10;:32:::1;:::i;:::-;60377:16;:51:::0;60472:10:::1;::::0;:19:::1;::::0;60485:6:::1;60472:19;:::i;:::-;60453:16;;:38;;;;:::i;:::-;60439:11;:52:::0;60502:7:::1;:14:::0;;-1:-1:-1;;;;;60527:15:0;::::1;-1:-1:-1::0;;;;;;60527:15:0;;;;-1:-1:-1;;;60527:15:0;;;60585:36:::1;60605:16:::0;60585:17;:36:::1;:::i;:::-;:45;::::0;60624:6:::1;60585:45;:::i;:::-;60570:11;;:60;;;;:::i;:::-;60553:14;:77:::0;60641:16:::1;:14;:16::i;:::-;60668:24;:22;:24::i;:::-;27680:14:::0;27676:102;;;27727:5;27711:21;;-1:-1:-1;;27711:21:0;;;27752:14;;-1:-1:-1;12511:36:1;;27752:14:0;;12499:2:1;12484:18;27752:14:0;;;;;;;27676:102;27287:498;59638:1062;;;;;;;;;:::o;41120:118::-;41185:7;41212:18;41220:9;41212:7;:18::i;:::-;41205:25;41120:118;-1:-1:-1;;41120:118:0:o;56508:211::-;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;56611:56:::1;::::0;-1:-1:-1;;;56611:56:0;;-1:-1:-1;;;;;12750:32:1;;;56611:56:0::1;::::0;::::1;12732:51:1::0;12799:18;;;12792:34;;;56611::0;::::1;::::0;::::1;::::0;12705:18:1;;56611:56:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;56683:28:0::1;::::0;56704:6;;-1:-1:-1;;;;;56683:28:0;::::1;::::0;::::1;::::0;;;::::1;56508:211:::0;;;:::o;56342:160::-;56398:5;;:57;;-1:-1:-1;;;;;56398:5:0;56421:10;56441:4;56448:6;56398:22;:57::i;:::-;56488:6;56466:18;;:28;;;;;;;:::i;:::-;;;;-1:-1:-1;;;56342:160:0:o;48274:84::-;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;48336:6:::1;:14:::0;;-1:-1:-1;;;;;;48336:14:0::1;-1:-1:-1::0;;;;;48336:14:0;;;::::1;::::0;;;::::1;::::0;;48274:84::o;56725:2242::-;56789:7;56797;56805;56913:11;;56894:15;:30;56890:2070;;56960:11;;57002:3;;-1:-1:-1;;;;;57061:16:0;;56941;57061;;;:9;:16;;;;;:31;;;:36;;57057:310;;57139:11;;57154:1;57139:16;57136:37;;57165:1;57168;57171;57157:16;;;;;;;;;;;57136:37;57209:30;57230:8;57210:15;57209:30;:::i;:::-;57192:47;;57057:310;;;-1:-1:-1;;;;;57319:16:0;;;;;;:9;:16;;;;;:31;;;57298:53;;57299:15;57298:53;:::i;:::-;57282:69;;57057:310;-1:-1:-1;;;;;57389:16:0;;;;;;:9;:16;;;;;:36;;;:41;;57385:119;;57459:1;57462;57465;57451:16;;;;;;;;;;;57385:119;57522:32;;57634:26;57654:5;57635:14;57634:26;:::i;:::-;-1:-1:-1;;;;;57721:16:0;;;;;;:9;:16;;;;;:36;;;57607:53;;-1:-1:-1;57693:64:0;;57689:168;;-1:-1:-1;;;;;57805:16:0;;;;;;:9;:16;;;;;:36;;;;-1:-1:-1;57689:168:0;-1:-1:-1;;;;;57916:16:0;;;;;;:9;:16;;;;;:30;;;57889:57;;:24;:57;:::i;:::-;-1:-1:-1;;;;;57985:16:0;;57961:21;57985:16;;;:9;:16;;;;;:36;;;;58056:31;;;;58132:39;;;;;57871:75;;-1:-1:-1;57985:36:0;58132:39;;58190:41;;;58186:704;;58257:28;;;58281:4;58257:28;58254:272;;-1:-1:-1;58321:7:0;-1:-1:-1;58330:1:0;;-1:-1:-1;58330:1:0;;-1:-1:-1;58313:22:0;;-1:-1:-1;;;;;;58313:22:0;58254:272;-1:-1:-1;;;;;58412:16:0;;58390:19;58412:16;;;:9;:16;;;;;:27;;;:37;;58442:7;;58412:37;:::i;:::-;58390:59;-1:-1:-1;58497:1:0;;-1:-1:-1;58497:1:0;;-1:-1:-1;58476:26:0;;-1:-1:-1;;;;;;;;;58476:26:0;58186:704;58569:28;;;58593:4;58569:28;58566:305;;-1:-1:-1;58632:15:0;;-1:-1:-1;58649:13:0;-1:-1:-1;58664:7:0;-1:-1:-1;58624:48:0;;-1:-1:-1;;;;58624:48:0;58566:305;-1:-1:-1;;;;;58749:16:0;;58727:19;58749:16;;;:9;:16;;;;;:27;;;:45;;58779:15;;58749:45;:::i;56890:2070::-;-1:-1:-1;58936:1:0;;-1:-1:-1;58936:1:0;;-1:-1:-1;58936:1:0;56890:2070;56725:2242;;;;;:::o;61190:172::-;60767:12;;-1:-1:-1;;;;;60767:12:0;60753:10;:26;60745:70;;;;-1:-1:-1;;;60745:70:0;;13543:2:1;60745:70:0;;;13525:21:1;13582:2;13562:18;;;13555:30;13621:33;13601:18;;;13594:61;13672:18;;60745:70:0;13341:355:1;60745:70:0;61282:12:::1;::::0;61263:32:::1;::::0;-1:-1:-1;;;;;61282:12:0::1;61263:18;:32::i;:::-;61306:12;:25:::0;;-1:-1:-1;;;;;;61306:25:0::1;::::0;;61190:172::o;59008:333::-;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;59080:12:::1;:25:::0;;;59148:10:::1;::::0;:19:::1;::::0;59161:6:::1;59148:19;:::i;:::-;59135:32;::::0;:10;:32:::1;:::i;:::-;59116:16;:51:::0;59211:10:::1;::::0;:19:::1;::::0;59224:6:::1;59211:19;:::i;:::-;59192:16;;:38;;;;:::i;:::-;59178:11;:52:::0;59292:3:::1;::::0;59273:16:::1;::::0;:22:::1;::::0;59292:3;59273:22:::1;:::i;:::-;59258:11;;:37;;;;:::i;:::-;59241:14;:54:::0;59311:22:::1;::::0;817:25:1;;;59311:22:0::1;::::0;805:2:1;790:18;59311:22:0::1;671:177:1::0;51528:256:0;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51610:25:0;::::1;;::::0;;;:11:::1;:25;::::0;;;;;::::1;;51602:51;;;::::0;-1:-1:-1;;;51602:51:0;;13903:2:1;51602:51:0::1;::::0;::::1;13885:21:1::0;13942:2;13922:18;;;13915:30;-1:-1:-1;;;13961:18:1;;;13954:44;14015:18;;51602:51:0::1;13701:338:1::0;51602:51:0::1;-1:-1:-1::0;;;;;51671:23:0;::::1;;::::0;;;:9:::1;:23;::::0;;;;;;;51664:30;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;;::::0;;-1:-1:-1;;51664:30:0;;::::1;::::0;;;51705:11:::1;:25:::0;;;;;;:31;;;;::::1;::::0;;;51752:24;;999:51:1;;;51752:24:0::1;::::0;972:18:1;51752:24:0::1;853:203:1::0;50267:1199:0;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;35454:21:::1;:19;:21::i;:::-;50383:2:::2;50370:4;:11;:15;;50362:45;;;::::0;-1:-1:-1;;;50362:45:0;;14246:2:1;50362:45:0::2;::::0;::::2;14228:21:1::0;14285:2;14265:18;;;14258:30;-1:-1:-1;;;14304:18:1;;;14297:48;14362:18;;50362:45:0::2;14044:342:1::0;50362:45:0::2;50423:6;50418:1041;50438:4;:11;50434:1;:15;50418:1041;;;50480:11;:28;50492:4;50497:1;50492:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;50480:28:0::2;::::0;;;::::2;::::0;;;;;;50492:15:::2;50480:28:::0;;::::2;;50479:29;50470:60;;;::::0;-1:-1:-1;;;50470:60:0;;14725:2:1;50470:60:0::2;::::0;::::2;14707:21:1::0;14764:2;14744:18;;;14737:30;-1:-1:-1;;;14783:18:1;;;14776:48;14841:18;;50470:60:0::2;14523:342:1::0;50470:60:0::2;50576:4;50545:11;:28;50557:4;50562:1;50557:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;50545:28:0::2;::::0;;;::::2;::::0;;;;;;-1:-1:-1;50545:28:0;:35;;-1:-1:-1;;50545:35:0::2;::::0;::::2;;::::0;;;::::2;::::0;;50595:31:::2;;:::i;:::-;50665:4;50670:1;50665:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:14:::2;::::0;50641:38;;;50694:23:::2;::::0;::::2;:47:::0;;;50787:16:::2;::::0;50756:28:::2;::::0;::::2;:47:::0;50870:17:::2;::::0;50891:3:::2;::::0;50843:45:::2;::::0;50870:17;50843:45:::2;:::i;:::-;50842:52;;;;:::i;:::-;50818:22;::::0;::::2;:76:::0;50958:22:::2;::::0;50932:21;;50984:3:::2;::::0;50931:50:::2;::::0;::::2;:::i;:::-;50930:57;;;;:::i;:::-;50909:19;::::0;::::2;:78:::0;;;51105:16:::2;::::0;51055:22:::2;::::0;::::2;::::0;51029:21;;51105:16;;50909:78;51028:50:::2;::::0;51055:22;51028:50:::2;:::i;:::-;:74;;;;:::i;:::-;51027:94;;;;:::i;:::-;51002:22;::::0;::::2;:119:::0;51139:22:::2;::::0;::::2;::::0;:27;:55;::::2;;;-1:-1:-1::0;51170:19:0::2;::::0;::::2;::::0;:24;51139:55:::2;51136:132;;;51248:4;51214:31;::::0;::::2;:38:::0;51136:132:::2;51311:8;51282:9;:26;51292:4;51297:1;51292:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;51282:26:0::2;::::0;;;;::::2;::::0;;;;;;;;-1:-1:-1;51282:26:0;;;:37;;;;;;::::2;::::0;::::2;::::0;::::2;::::0;;;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;;::::2;::::0;::::2;::::0;;::::2;::::0;;-1:-1:-1;;51282:37:0::2;::::0;::::2;;::::0;;;::::2;::::0;;51359:21;;51335:20:::2;:45:::0;;51359:21;;51335:20;;:45:::2;::::0;51359:21;;51335:45:::2;:::i;:::-;;;;;;;;51400:47;51416:4;51421:1;51416:7;;;;;;;;:::i;:::-;;;;;;;:15;;;51432:4;51437:1;51432:7;;;;;;;;:::i;:::-;;;;;;;:14;;;51400:47;;;;;;-1:-1:-1::0;;;;;12750:32:1;;;;12732:51;;12814:2;12799:18;;12792:34;12720:2;12705:18;;12558:274;51400:47:0::2;;;;;;;;-1:-1:-1::0;50450:3:0::2;;50418:1041;;;;35498:20:::1;34715:1:::0;36018:7;:22;35835:213;49006:1204;35454:21;:19;:21::i;:::-;49120:10:::1;49110:21;::::0;;;:9:::1;:21;::::0;;;;;;;49132:17:::1;::::0;::::1;::::0;49110:40;;;;;;;;::::1;;49109:41;49101:74;;;::::0;-1:-1:-1;;;49101:74:0;;10632:2:1;49101:74:0::1;::::0;::::1;10614:21:1::0;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:51;10751:18;;49101:74:0::1;10430:345:1::0;49101:74:0::1;49216:6;::::0;-1:-1:-1;;;;;49216:6:0::1;49194:18;49204:7:::0;49194:9:::1;:18::i;:::-;-1:-1:-1::0;;;;;49194:28:0::1;;49186:55;;;::::0;-1:-1:-1;;;49186:55:0;;10982:2:1;49186:55:0::1;::::0;::::1;10964:21:1::0;11021:2;11001:18;;;10994:30;-1:-1:-1;;;11040:18:1;;;11033:44;11094:18;;49186:55:0::1;10780:338:1::0;49186:55:0::1;49274:10;49262:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;49261:24;49252:55;;;::::0;-1:-1:-1;;;49252:55:0;;14725:2:1;49252:55:0::1;::::0;::::1;14707:21:1::0;14764:2;14744:18;;;14737:30;-1:-1:-1;;;14783:18:1;;;14776:48;14841:18;;49252:55:0::1;14523:342:1::0;49252:55:0::1;49328:10;49318:21;::::0;;;:9:::1;:21;::::0;;;;;;;49340:17:::1;::::0;::::1;::::0;49318:40;;;;;;;:45;;49359:4:::1;-1:-1:-1::0;;49318:45:0;;::::1;::::0;::::1;::::0;;;49374:23;;;:11:::1;:23:::0;;;;;;:30;;;;::::1;;::::0;;49415:31:::1;;:::i;:::-;49457:30:::0;;;49498:23:::1;::::0;::::1;:47:::0;;;49587:16:::1;::::0;49556:28:::1;::::0;::::1;:47:::0;49666:17:::1;::::0;49687:3:::1;::::0;49639:45:::1;::::0;49481:6;49639:45:::1;:::i;:::-;49638:52;;;;:::i;:::-;49614:22;::::0;::::1;:76:::0;49750:22:::1;::::0;49724:21;;49776:3:::1;::::0;49723:50:::1;::::0;::::1;:::i;:::-;49722:57;;;;:::i;:::-;49701:19;::::0;::::1;:78:::0;;;49893:16:::1;::::0;49843:22:::1;::::0;::::1;::::0;49817:21;;49893:16;;49701:78;49816:50:::1;::::0;49843:22;49816:50:::1;:::i;:::-;:74;;;;:::i;:::-;49815:94;;;;:::i;:::-;49790:22;::::0;::::1;:119:::0;49923:22:::1;::::0;::::1;::::0;:27;:55;::::1;;;-1:-1:-1::0;49954:19:0::1;::::0;::::1;::::0;:24;49923:55:::1;49920:124;;;50028:4;49994:31;::::0;::::1;:38:::0;49920:124:::1;50064:19:::0;;-1:-1:-1;;;;;50054:30:0::1;;::::0;;;:9:::1;:30;::::0;;;;;;;:41;;;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;;-1:-1:-1;;50054:41:0::1;::::0;::::1;;::::0;;;::::1;::::0;;50107:20:::1;:45:::0;;50054:41;;50107:20;;:45:::1;::::0;50054:41;;50107:45:::1;:::i;:::-;::::0;;;-1:-1:-1;;50168:34:0::1;::::0;;50184:10:::1;12732:51:1::0;;12814:2;12799:18;;12792:34;;;50168::0::1;::::0;12705:18:1;50168:34:0::1;;;;;;;49090:1120;35498:20:::0;34715:1;36018:7;:22;35835:213;35498:20;49006:1204;;:::o;60890:247::-;32134:6;;-1:-1:-1;;;;;32134:6:0;31029:10;32281:23;32273:68;;;;-1:-1:-1;;;32273:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;60981:22:0;::::1;60973:57;;;::::0;-1:-1:-1;;;60973:57:0;;15072:2:1;60973:57:0::1;::::0;::::1;15054:21:1::0;15111:2;15091:18;;;15084:30;-1:-1:-1;;;15130:18:1;;;15123:52;15192:18;;60973:57:0::1;14870:346:1::0;60973:57:0::1;61041:12;:23:::0;;-1:-1:-1;;;;;61041:23:0;::::1;-1:-1:-1::0;;;;;;61041:23:0;;::::1;::::0;::::1;::::0;;;61107:7:::1;32134:6:::0;;-1:-1:-1;;;;;32134:6:0;;32061:87;61107:7:::1;-1:-1:-1::0;;;;;61080:49:0::1;;;;;;;;;;;60890:247:::0;:::o;48008:129::-;48071:22;;:::i;:::-;-1:-1:-1;;;;;;48113:16:0;;;;;:9;:16;;;;;;;;;48106:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48008:129::o;35534:293::-;34759:1;35668:7;;:19;35660:63;;;;-1:-1:-1;;;35660:63:0;;15423:2:1;35660:63:0;;;15405:21:1;15462:2;15442:18;;;15435:30;15501:33;15481:18;;;15474:61;15552:18;;35660:63:0;15221:355:1;35660:63:0;34759:1;35801:7;:18;35534:293::o;52619:3639::-;47372:7;;52671;;-1:-1:-1;;;47372:7:0;;;;:15;;47383:4;47372:15;47364:47;;;;-1:-1:-1;;;47364:47:0;;9932:2:1;47364:47:0;;;9914:21:1;9971:2;9951:18;;;9944:30;-1:-1:-1;;;9990:18:1;;;9983:49;10049:18;;47364:47:0;9730:343:1;47364:47:0;52718:11:::1;;52699:15;:30;52695:3556;;52767:11;::::0;52750:14:::1;:28:::0;52953:10:::1;-1:-1:-1::0;52943:21:0;;;:9:::1;:21;::::0;;;;:36:::1;;::::0;:41;;52939:447:::1;;53015:14;;53033:1;53015:19:::0;53011:112:::1;;53070:1;53063:8;;;52619:3639:::0;:::o;53011:112::-:1;53182:14;::::0;53164:32:::1;::::0;:15:::1;:32;:::i;:::-;53147:49;;52939:447;;;53340:10;53330:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;::::0;53287:79:::1;::::0;:15:::1;:79;:::i;:::-;53245:121;;52939:447;53406:32;53458:3;;53441:14;:20;;;;:::i;:::-;53568:10;53558:21;::::0;;;:9:::1;:21;::::0;;;;:41:::1;;::::0;53406:55;;-1:-1:-1;53558:46:0;53554:124:::1;;53636:1;53629:8;;;;52619:3639:::0;:::o;53554:124::-:1;53777:24;53805:1;53777:29:::0;53773:127:::1;;53838:1;53831:8;;;;52619:3639:::0;:::o;53773:127::-:1;54005:10;53995:21;::::0;;;:9:::1;:21;::::0;;;;:41:::1;;::::0;53946:90;::::1;53920:273;;-1:-1:-1::0;54116:10:0::1;54106:21;::::0;;;:9:::1;:21;::::0;;;;:67:::1;;::::0;53920:273:::1;54297:10;54213:23;54287:21:::0;;;:9:::1;:21;::::0;;;;:35:::1;;::::0;54239:83:::1;::::0;:24;:83:::1;:::i;:::-;54378:10;54343:22;54368:21:::0;;;:9:::1;:21;::::0;;;;:63:::1;::::0;::::1;::::0;;54468:36:::1;::::0;;::::1;::::0;54213:109;;-1:-1:-1;54368:63:0;;54468:36;54590:24;;54368:63;54523:91:::1;54590:24:::0;54368:63;54523:91:::1;:::i;:::-;::::0;;;-1:-1:-1;;54752:10:0::1;54742:21;::::0;;;:9:::1;:21;::::0;;;;:35:::1;;::::0;54694:83:::1;::::0;:24;:83:::1;:::i;:::-;54643:10;54633:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;:144:::0;;:36;;:21;:144:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;54806:10:0::1;54796:21;::::0;;;:9:::1;:21;::::0;;;;54835:15:::1;54796:36;::::0;::::1;:54:::0;;;54869:45:::1;::::0;::::1;:63:::0;54983:44:::1;;::::0;::::1;;55050:42:::0;;;55046:1105:::1;;55121:28:::0;::::1;;55145:4;55121:28:::0;55118:475:::1;;-1:-1:-1::0;55184:7:0;-1:-1:-1;55177:14:0::1;::::0;-1:-1:-1;;;;55177:14:0::1;55118:475;55278:10;55246:19;55268:21:::0;;;:9:::1;:21;::::0;;;;:32:::1;;::::0;:41:::1;::::0;55302:7;;55268:41:::1;:::i;:::-;55346:10;55336:21;::::0;;;:9:::1;:21;::::0;;;;:44:::1;::::0;::::1;:51:::0;;-1:-1:-1;;55336:51:0::1;55383:4;55336:51;::::0;;55489:35:::1;::::0;::::1;::::0;55454:32:::1;::::0;;::::1;::::0;55246:63;;-1:-1:-1;55454:70:0::1;::::0;::::1;:::i;:::-;55424:10;55414:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;:110:::0;;:36;;:21;:110:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;55558:11:0;;-1:-1:-1;55551:18:0::1;::::0;-1:-1:-1;;;;;;;55551:18:0::1;55046:1105;55644:28:::0;::::1;;55668:4;55644:28:::0;55641:491:::1;;-1:-1:-1::0;55707:15:0;;52619:3639;-1:-1:-1;;;;;52619:3639:0:o;55641:491::-:1;55809:10;55777:19;55799:21:::0;;;:9:::1;:21;::::0;;;;:32:::1;;::::0;:49:::1;::::0;55833:15;;55799:49:::1;:::i;52695:3556::-;-1:-1:-1::0;56198:1:0::1;52695:3556;52619:3639:::0;:::o;42240:222::-;42395:58;;-1:-1:-1;;;;;12750:32:1;;42395:58:0;;;12732:51:1;12799:18;;;12792:34;;;42368:86:0;;42388:5;;-1:-1:-1;;;42418:23:0;12705:18:1;;42395:58:0;;;;-1:-1:-1;;42395:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;42395:58:0;-1:-1:-1;;;;;;42395:58:0;;;;;;;;;;42368:19;:86::i;:::-;42240:222;;;:::o;35835:213::-;34715:1;36018:7;:22;35835:213::o;31762:97::-;29441:13;;;;;;;29433:69;;;;-1:-1:-1;;;29433:69:0;;;;;;;:::i;:::-;31825:26:::1;:24;:26::i;:::-;31762:97::o:0;34801:113::-;29441:13;;;;;;;29433:69;;;;-1:-1:-1;;;29433:69:0;;;;;;;:::i;:::-;34872:34:::1;:32;:34::i;41966:186::-:0;42031:7;42051:14;42068:16;42074:9;42068:5;:16::i;:::-;42051:33;;42102:42;42116:6;42124:9;:19;;;42102:13;:42::i;:::-;42095:49;41966:186;-1:-1:-1;;;41966:186:0:o;42470:259::-;42652:68;;-1:-1:-1;;;;;16251:15:1;;;42652:68:0;;;16233:34:1;16303:15;;16283:18;;;16276:43;16335:18;;;16328:34;;;42625:96:0;;42645:5;;-1:-1:-1;;;42675:27:0;16168:18:1;;42652:68:0;15993:375:1;42625:96:0;42470:259;;;;:::o;33353:191::-;33446:6;;;-1:-1:-1;;;;;33463:17:0;;;-1:-1:-1;;;;;;33463:17:0;;;;;;;33496:40;;33446:6;;;33463:17;33446:6;;33496:40;;33427:16;;33496:40;33416:128;33353:191;:::o;45373:727::-;45808:23;45834:69;45862:4;45834:69;;;;;;;;;;;;;;;;;45842:5;-1:-1:-1;;;;;45834:27:0;;;:69;;;;;:::i;:::-;45918:17;;45808:95;;-1:-1:-1;45918:21:0;45914:179;;46015:10;46004:30;;;;;;;;;;;;:::i;:::-;45996:85;;;;-1:-1:-1;;;45996:85:0;;16575:2:1;45996:85:0;;;16557:21:1;16614:2;16594:18;;;16587:30;16653:34;16633:18;;;16626:62;-1:-1:-1;;;16704:18:1;;;16697:40;16754:19;;45996:85:0;16373:406:1;31867:113:0;29441:13;;;;;;;29433:69;;;;-1:-1:-1;;;29433:69:0;;;;;;;:::i;:::-;31940:32:::1;31029:10:::0;31940:18:::1;:32::i;34922:111::-:0;29441:13;;;;;;;29433:69;;;;-1:-1:-1;;;29433:69:0;;;;;;;:::i;41352:606::-;41415:7;41455:495;41559:149;41735:9;:21;;;41783:9;:25;;;41835:9;:12;;;41874:9;:19;;;41522:394;;;;;;;;;;;17043:25:1;;;-1:-1:-1;;;;;17142:15:1;;;17137:2;17122:18;;17115:43;17194:15;;;;17189:2;17174:18;;17167:43;17241:2;17226:18;;17219:34;;;;17284:3;17269:19;;17262:35;17030:3;17015:19;;16784:519;41522:394:0;;;;;;;;;;;;;41490:445;;;;;;41455:16;:495::i;8874:263::-;8979:7;9005:17;9024:18;9046:27;9057:4;9063:9;9046:10;:27::i;:::-;9004:69;;;;9084:18;9096:5;9084:11;:18::i;:::-;-1:-1:-1;9120:9:0;8874:263;-1:-1:-1;;;8874:263:0:o;18190:229::-;18327:12;18359:52;18381:6;18389:4;18395:1;18398:12;18359:21;:52::i;:::-;18352:59;18190:229;-1:-1:-1;;;;18190:229:0:o;26173:208::-;26286:7;26318:55;26340:20;:18;:20::i;:::-;26362:10;14329:57;;-1:-1:-1;;;14329:57:0;;;19930:27:1;19973:11;;;19966:27;;;20009:12;;;20002:28;;;14256:7:0;;20046:12:1;;14329:57:0;;;;;;;;;;;;14301:100;;;;;;14281:120;;14136:273;;;;;6732:1340;6840:7;6849:12;7079:9;:16;7099:2;7079:22;7075:990;;7375:4;7360:20;;7354:27;7425:4;7410:20;;7404:27;7483:4;7468:20;;7462:27;7118:9;7454:36;7526:25;7537:4;7454:36;7354:27;7404;7526:10;:25::i;:::-;7519:32;;;;;;;;;7075:990;7573:9;:16;7593:2;7573:22;7569:496;;7848:4;7833:20;;7827:27;7899:4;7884:20;;7878:27;7941:23;7952:4;7827:27;7878;7941:10;:23::i;:::-;7934:30;;;;;;;;7569:496;-1:-1:-1;8013:1:0;;-1:-1:-1;8017:35:0;7569:496;6732:1340;;;;;:::o;5003:643::-;5081:20;5072:5;:29;;;;;;;;:::i;:::-;;5068:571;;5003:643;:::o;5068:571::-;5179:29;5170:5;:38;;;;;;;;:::i;:::-;;5166:473;;5225:34;;-1:-1:-1;;;5225:34:0;;17642:2:1;5225:34:0;;;17624:21:1;17681:2;17661:18;;;17654:30;17720:26;17700:18;;;17693:54;17764:18;;5225:34:0;17440:348:1;5166:473:0;5290:35;5281:5;:44;;;;;;;;:::i;:::-;;5277:362;;5342:41;;-1:-1:-1;;;5342:41:0;;17995:2:1;5342:41:0;;;17977:21:1;18034:2;18014:18;;;18007:30;18073:33;18053:18;;;18046:61;18124:18;;5342:41:0;17793:355:1;5277:362:0;5414:30;5405:5;:39;;;;;;;;:::i;:::-;;5401:238;;5461:44;;-1:-1:-1;;;5461:44:0;;18355:2:1;5461:44:0;;;18337:21:1;18394:2;18374:18;;;18367:30;18433:34;18413:18;;;18406:62;-1:-1:-1;;;18484:18:1;;;18477:32;18526:19;;5461:44:0;18153:398:1;5401:238:0;5536:30;5527:5;:39;;;;;;;;:::i;:::-;;5523:116;;5583:44;;-1:-1:-1;;;5583:44:0;;18758:2:1;5583:44:0;;;18740:21:1;18797:2;18777:18;;;18770:30;18836:34;18816:18;;;18809:62;-1:-1:-1;;;18887:18:1;;;18880:32;18929:19;;5583:44:0;18556:398:1;19310:455:0;19480:12;19538:5;19513:21;:30;;19505:81;;;;-1:-1:-1;;;19505:81:0;;19161:2:1;19505:81:0;;;19143:21:1;19200:2;19180:18;;;19173:30;19239:34;19219:18;;;19212:62;-1:-1:-1;;;19290:18:1;;;19283:36;19336:19;;19505:81:0;18959:402:1;19505:81:0;19598:12;19612:23;19639:6;-1:-1:-1;;;;;19639:11:0;19658:5;19665:4;19639:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19597:73;;;;19688:69;19715:6;19723:7;19732:10;19744:12;19688:26;:69::i;:::-;19681:76;19310:455;-1:-1:-1;;;;;;;19310:455:0:o;24654:437::-;24707:7;24753:4;-1:-1:-1;;;;;24762:12:0;24745:29;;:66;;;;;24795:16;24778:13;:33;24745:66;24727:357;;;-1:-1:-1;24845:24:0;;24654:437::o;24727:357::-;-1:-1:-1;25311:197:0;;;24970:10;25311:197;;;;21089:25:1;;;;25003:12:0;21130:18:1;;;21123:34;25038:15:0;21173:18:1;;;21166:34;25440:13:0;21216:18:1;;;21209:34;25484:4:0;21259:19:1;;;;21252:61;;;;25311:197:0;;;;;;;;;;21061:19:1;;;;25311:197:0;;;25283:240;;;;;;48145:121::o;10403:1669::-;10534:7;;11495:66;11469:92;;11451:200;;;-1:-1:-1;11604:1:0;;-1:-1:-1;11608:30:0;11588:51;;11451:200;11665:1;:7;;11670:2;11665:7;;:18;;;;;11676:1;:7;;11681:2;11676:7;;11665:18;11661:102;;;-1:-1:-1;11716:1:0;;-1:-1:-1;11720:30:0;11700:51;;11661:102;11877:24;;;11860:14;11877:24;;;;;;;;;20296:25:1;;;20369:4;20357:17;;20337:18;;;20330:45;;;;20391:18;;;20384:34;;;20434:18;;;20427:34;;;11877:24:0;;20268:19:1;;11877:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11877:24:0;;-1:-1:-1;;11877:24:0;;;-1:-1:-1;;;;;;;11916:20:0;;11912:103;;11969:1;11973:29;11953:50;;;;;;;11912:103;12035:6;-1:-1:-1;12043:20:0;;-1:-1:-1;10403:1669:0;;;;;;;;:::o;9400:389::-;9514:7;;-1:-1:-1;;;;;9560:125:0;;9514:7;9712:25;9728:3;9713:18;;;9735:2;9712:25;:::i;:::-;9696:42;;9756:25;9767:4;9773:1;9776;9779;9756:10;:25::i;:::-;9749:32;;;;;;9400:389;;;;;;:::o;20970:644::-;21155:12;21184:7;21180:427;;;21212:10;:17;21233:1;21212:22;21208:290;;-1:-1:-1;;;;;15728:19:0;;;21422:60;;;;-1:-1:-1;;;21422:60:0;;20674:2:1;21422:60:0;;;20656:21:1;20713:2;20693:18;;;20686:30;20752:31;20732:18;;;20725:59;20801:18;;21422:60:0;20472:353:1;21422:60:0;-1:-1:-1;21519:10:0;21512:17;;21180:427;21562:33;21570:10;21582:12;22317:17;;:21;22313:388;;22549:10;22543:17;22606:15;22593:10;22589:2;22585:19;22578:44;22313:388;22676:12;22669:20;;-1:-1:-1;;;22669:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;1061:127::-;1122:10;1117:3;1113:20;1110:1;1103:31;1153:4;1150:1;1143:15;1177:4;1174:1;1167:15;1193:253;1265:2;1259:9;1307:4;1295:17;;1342:18;1327:34;;1363:22;;;1324:62;1321:88;;;1389:18;;:::i;:::-;1425:2;1418:22;1193:253;:::o;1451:257::-;1523:4;1517:11;;;1555:17;;1602:18;1587:34;;1623:22;;;1584:62;1581:88;;;1649:18;;:::i;1713:275::-;1784:2;1778:9;1849:2;1830:13;;-1:-1:-1;;1826:27:1;1814:40;;1884:18;1869:34;;1905:22;;;1866:62;1863:88;;;1931:18;;:::i;:::-;1967:2;1960:22;1713:275;;-1:-1:-1;1713:275:1:o;1993:1056::-;2046:5;2094:4;2082:9;2077:3;2073:19;2069:30;2066:50;;;2112:1;2109;2102:12;2066:50;2134:22;;:::i;:::-;2125:31;;2179:29;2198:9;2179:29;:::i;:::-;2172:5;2165:44;2228:2;2262:38;2296:2;2285:9;2281:18;2262:38;:::i;:::-;2257:2;2250:5;2246:14;2239:62;2361:2;2350:9;2346:18;2333:32;2328:2;2321:5;2317:14;2310:56;2426:2;2415:9;2411:18;2398:32;2393:2;2386:5;2382:14;2375:56;2482:3;2471:9;2467:19;2454:33;2506:18;2547:2;2539:6;2536:14;2533:34;;;2563:1;2560;2553:12;2533:34;2601:6;2590:9;2586:22;2576:32;;2646:3;2639:4;2635:2;2631:13;2627:23;2617:51;;2664:1;2661;2654:12;2617:51;2700:2;2687:16;2722:2;2718;2715:10;2712:36;;;2728:18;;:::i;:::-;2770:53;2813:2;2794:13;;-1:-1:-1;;2790:27:1;2786:36;;2770:53;:::i;:::-;2757:66;;2846:2;2839:5;2832:17;2886:3;2881:2;2876;2872;2868:11;2864:20;2861:29;2858:49;;;2903:1;2900;2893:12;2858:49;2958:2;2953;2949;2945:11;2940:2;2933:5;2929:14;2916:45;3002:1;2997:2;2992;2985:5;2981:14;2977:23;2970:34;;3037:5;3031:3;3024:5;3020:15;3013:30;;;;1993:1056;;;;:::o;3054:343::-;3137:6;3190:2;3178:9;3169:7;3165:23;3161:32;3158:52;;;3206:1;3203;3196:12;3158:52;3246:9;3233:23;3279:18;3271:6;3268:30;3265:50;;;3311:1;3308;3301:12;3265:50;3334:57;3383:7;3374:6;3363:9;3359:22;3334:57;:::i;3402:742::-;3533:6;3541;3549;3557;3565;3573;3581;3589;3597;3650:3;3638:9;3629:7;3625:23;3621:33;3618:53;;;3667:1;3664;3657:12;3618:53;3690:29;3709:9;3690:29;:::i;:::-;3680:39;;3766:2;3755:9;3751:18;3738:32;3728:42;;3817:2;3806:9;3802:18;3789:32;3779:42;;3868:2;3857:9;3853:18;3840:32;3830:42;;3919:3;3908:9;3904:19;3891:33;3881:43;;3943:39;3977:3;3966:9;3962:19;3943:39;:::i;:::-;3933:49;;4029:3;4018:9;4014:19;4001:33;3991:43;;4081:3;4070:9;4066:19;4053:33;4043:43;;4133:3;4122:9;4118:19;4105:33;4095:43;;3402:742;;;;;;;;;;;:::o;4149:328::-;4226:6;4234;4242;4295:2;4283:9;4274:7;4270:23;4266:32;4263:52;;;4311:1;4308;4301:12;4263:52;4334:29;4353:9;4334:29;:::i;:::-;4324:39;;4382:38;4416:2;4405:9;4401:18;4382:38;:::i;:::-;4372:48;;4467:2;4456:9;4452:18;4439:32;4429:42;;4149:328;;;;;:::o;4482:180::-;4541:6;4594:2;4582:9;4573:7;4569:23;4565:32;4562:52;;;4610:1;4607;4600:12;4562:52;-1:-1:-1;4633:23:1;;4482:180;-1:-1:-1;4482:180:1:o;4991:1172::-;5101:6;5132:2;5175;5163:9;5154:7;5150:23;5146:32;5143:52;;;5191:1;5188;5181:12;5143:52;5231:9;5218:23;5260:18;5301:2;5293:6;5290:14;5287:34;;;5317:1;5314;5307:12;5287:34;5355:6;5344:9;5340:22;5330:32;;5400:7;5393:4;5389:2;5385:13;5381:27;5371:55;;5422:1;5419;5412:12;5371:55;5458:2;5445:16;5480:2;5476;5473:10;5470:36;;;5486:18;;:::i;:::-;5526:36;5558:2;5553;5550:1;5546:10;5542:19;5526:36;:::i;:::-;5596:15;;;5627:12;;;;-1:-1:-1;5678:1:1;5674:10;;;;5666:19;;5662:28;;;5702:19;;;5699:39;;;5734:1;5731;5724:12;5699:39;5758:11;;;;5778:355;5794:6;5789:3;5786:15;5778:355;;;5876:4;5870:3;5861:7;5857:17;5853:28;5850:48;;;5894:1;5891;5884:12;5850:48;5924:22;;:::i;:::-;5973:23;5992:3;5973:23;:::i;:::-;5959:38;;6046:12;;;6033:26;6017:14;;;6010:50;6073:18;;5820:4;5811:14;;;;6111:12;;;;5778:355;;6168:411;6260:6;6268;6321:2;6309:9;6300:7;6296:23;6292:32;6289:52;;;6337:1;6334;6327:12;6289:52;6373:9;6360:23;6350:33;;6434:2;6423:9;6419:18;6406:32;6461:18;6453:6;6450:30;6447:50;;;6493:1;6490;6483:12;6447:50;6516:57;6565:7;6556:6;6545:9;6541:22;6516:57;:::i;:::-;6506:67;;;6168:411;;;;;:::o;7422:910::-;7580:4;7622:3;7611:9;7607:19;7599:27;;7659:6;7653:13;7642:9;7635:32;7723:4;7715:6;7711:17;7705:24;7698:4;7687:9;7683:20;7676:54;7786:4;7778:6;7774:17;7768:24;7761:4;7750:9;7746:20;7739:54;7849:4;7841:6;7837:17;7831:24;7824:4;7813:9;7809:20;7802:54;7912:4;7904:6;7900:17;7894:24;7887:4;7876:9;7872:20;7865:54;7975:4;7967:6;7963:17;7957:24;7950:4;7939:9;7935:20;7928:54;8038:4;8030:6;8026:17;8020:24;8013:4;8002:9;7998:20;7991:54;8101:4;8093:6;8089:17;8083:24;8076:4;8065:9;8061:20;8054:54;8127:6;8187:2;8179:6;8175:15;8169:22;8164:2;8153:9;8149:18;8142:50;;8211:6;8264:2;8256:6;8252:15;8246:22;8277:49;8322:2;8311:9;8307:18;8293:12;453:13;446:21;434:34;;383:91;8277:49;;;7422:910;;;;:::o;8337:254::-;8405:6;8413;8466:2;8454:9;8445:7;8441:23;8437:32;8434:52;;;8482:1;8479;8472:12;8434:52;8505:29;8524:9;8505:29;:::i;:::-;8495:39;8581:2;8566:18;;;;8553:32;;-1:-1:-1;;;8337:254:1:o;8830:356::-;9032:2;9014:21;;;9051:18;;;9044:30;9110:34;9105:2;9090:18;;9083:62;9177:2;9162:18;;8830:356::o;9541:184::-;9611:6;9664:2;9652:9;9643:7;9639:23;9635:32;9632:52;;;9680:1;9677;9670:12;9632:52;-1:-1:-1;9703:16:1;;9541:184;-1:-1:-1;9541:184:1:o;11376:127::-;11437:10;11432:3;11428:20;11425:1;11418:31;11468:4;11465:1;11458:15;11492:4;11489:1;11482:15;11508:128;11575:9;;;11596:11;;;11593:37;;;11610:18;;:::i;12056:168::-;12129:9;;;12160;;12177:15;;;12171:22;;12157:37;12147:71;;12198:18;;:::i;12229:125::-;12294:9;;;12315:10;;;12312:36;;;12328:18;;:::i;12837:277::-;12904:6;12957:2;12945:9;12936:7;12932:23;12928:32;12925:52;;;12973:1;12970;12963:12;12925:52;13005:9;12999:16;13058:5;13051:13;13044:21;13037:5;13034:32;13024:60;;13080:1;13077;13070:12;13119:217;13159:1;13185;13175:132;;13229:10;13224:3;13220:20;13217:1;13210:31;13264:4;13261:1;13254:15;13292:4;13289:1;13282:15;13175:132;-1:-1:-1;13321:9:1;;13119:217::o;14391:127::-;14452:10;14447:3;14443:20;14440:1;14433:31;14483:4;14480:1;14473:15;14507:4;14504:1;14497:15;15581:407;15783:2;15765:21;;;15822:2;15802:18;;;15795:30;15861:34;15856:2;15841:18;;15834:62;-1:-1:-1;;;15927:2:1;15912:18;;15905:41;15978:3;15963:19;;15581:407::o;17308:127::-;17369:10;17364:3;17360:20;17357:1;17350:31;17400:4;17397:1;17390:15;17424:4;17421:1;17414:15;19366:301;19495:3;19533:6;19527:13;19579:6;19572:4;19564:6;19560:17;19555:3;19549:37;19641:1;19605:16;;19630:13;;;-1:-1:-1;19605:16:1;19366:301;-1:-1:-1;19366:301:1:o;21324:418::-;21473:2;21462:9;21455:21;21436:4;21505:6;21499:13;21548:6;21543:2;21532:9;21528:18;21521:34;21607:6;21602:2;21594:6;21590:15;21585:2;21574:9;21570:18;21564:50;21663:1;21658:2;21649:6;21638:9;21634:22;21630:31;21623:42;21733:2;21726;21722:7;21717:2;21709:6;21705:15;21701:29;21690:9;21686:45;21682:54;21674:62;;;21324:418;;;;:::o
Swarm Source
ipfs://5a32e07b7c6977e464e5bb1ac291799cbe7247a72892d70396782e1dd45920c9
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 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.