Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
14536957 | 884 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Minimal Proxy Contract for 0x90df3aca8e22d81129e70b9984e48808a2d43062
Contract Name:
FixedQuadraticTimelockedDelegatorUpgradeable
Compiler Version
v0.8.10+commit.fc410830
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./FixedQuadraticTokenTimelockUpgradeable.sol"; interface IVotingToken is IERC20 { function delegate(address delegatee) external; } /// @title a timelock for tokens allowing for bulk delegation /// @author Fei Protocol /// @notice allows the timelocked tokens to be delegated by the beneficiary while locked contract FixedQuadraticTimelockedDelegatorUpgradeable is FixedQuadraticTokenTimelockUpgradeable { /// @notice accept beneficiary role over timelocked TRIBE function acceptBeneficiary() public override { _setBeneficiary(msg.sender); } /// @notice delegate all held TRIBE to the `to` address function delegate(address to) public onlyBeneficiary { IVotingToken(address(lockedToken)).delegate(to); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; import "@openzeppelin/contracts/proxy/utils/Initializable.sol"; import "./FixedTokenTimelockUpgradeable.sol"; contract FixedQuadraticTokenTimelockUpgradeable is Initializable, FixedTokenTimelockUpgradeable { function initialize( address _beneficiary, uint256 _duration, address _lockedToken, uint256 _cliffDuration, address _clawbackAdmin, uint256 _lockedAmount, uint256 _startTime ) external initializer { __FixedTokenTimelock_init( _beneficiary, _duration, _lockedToken, _cliffDuration, _clawbackAdmin, _lockedAmount ); if (_startTime != 0) { startTime = _startTime; } } function _proportionAvailable( uint256 initialBalance, uint256 elapsed, uint256 duration ) internal pure override returns (uint256) { return initialBalance * elapsed * elapsed / duration / duration; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.0; import "../../utils/Address.sol"; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() initializer {} * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { // If the contract is initializing we ignore whether _initialized is set in order to support multiple // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the // contract may have been reentered. require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} modifier, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } function _isConstructor() private view returns (bool) { return !Address.isContract(address(this)); } }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; import "./TokenTimelockUpgradeable.sol"; abstract contract FixedTokenTimelockUpgradeable is TokenTimelockUpgradeable { /// @notice amount of tokens already claimed uint256 public claimedAmount; function __FixedTokenTimelock_init( address _beneficiary, uint256 _duration, address _lockedToken, uint256 _cliffDuration, address _clawbackAdmin, uint256 _lockedAmount ) internal onlyInitializing { __TokenTimelock_init( _beneficiary, _duration, _cliffDuration, _lockedToken, _clawbackAdmin ); require(_lockedAmount > 0, "FixedTokenTimelock: no amount locked"); initialBalance = _lockedAmount; } // Prevents incoming LP tokens from messing up calculations modifier balanceCheck() override { _; } /// @notice amount of tokens released to beneficiary function alreadyReleasedAmount() public view override returns (uint256) { return claimedAmount; } function _release(address to, uint256 amount) internal override { claimedAmount = claimedAmount + amount; lockedToken.transfer(to, amount); emit Release(beneficiary, to, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; // Inspired by OpenZeppelin TokenTimelock contract // Reference: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/TokenTimelock.sol import "@openzeppelin/contracts/proxy/utils/Initializable.sol"; import "../utils/TimedUpgradeable.sol"; import "./ITokenTimelock.sol"; abstract contract TokenTimelockUpgradeable is Initializable, ITokenTimelock, TimedUpgradeable { /// @notice ERC20 basic token contract being held in timelock IERC20 public override lockedToken; /// @notice beneficiary of tokens after they are released address public override beneficiary; /// @notice pending beneficiary appointed by current beneficiary address public override pendingBeneficiary; /// @notice initial balance of lockedToken uint256 public override initialBalance; uint256 internal lastBalance; /// @notice number of seconds before releasing is allowed uint256 public cliffSeconds; address public clawbackAdmin; function __TokenTimelock_init( address _beneficiary, uint256 _duration, uint256 _cliffSeconds, address _lockedToken, address _clawbackAdmin ) internal onlyInitializing { __Timed_init_unchained(_duration); __TokenTimelock_init_unchained( _beneficiary, _duration, _cliffSeconds, _lockedToken, _clawbackAdmin ); } function __TokenTimelock_init_unchained( address _beneficiary, uint256 _duration, uint256 _cliffSeconds, address _lockedToken, address _clawbackAdmin ) internal onlyInitializing { require(_duration != 0, "TokenTimelock: duration is 0"); require( _beneficiary != address(0), "TokenTimelock: Beneficiary must not be 0 address" ); beneficiary = _beneficiary; _initTimed(); _setLockedToken(_lockedToken); cliffSeconds = _cliffSeconds; clawbackAdmin = _clawbackAdmin; } // Prevents incoming LP tokens from messing up calculations modifier balanceCheck() virtual { if (totalToken() > lastBalance) { uint256 delta = totalToken() - lastBalance; initialBalance = initialBalance + delta; } _; lastBalance = totalToken(); } modifier onlyBeneficiary() { require( msg.sender == beneficiary, "TokenTimelock: Caller is not a beneficiary" ); _; } /// @notice releases `amount` unlocked tokens to address `to` function release(address to, uint256 amount) external override onlyBeneficiary balanceCheck { require(amount != 0, "TokenTimelock: no amount desired"); require(passedCliff(), "TokenTimelock: Cliff not passed"); uint256 available = availableForRelease(); require(amount <= available, "TokenTimelock: not enough released tokens"); _release(to, amount); } /// @notice releases maximum unlocked tokens to address `to` function releaseMax(address to) external override onlyBeneficiary balanceCheck { require(passedCliff(), "TokenTimelock: Cliff not passed"); _release(to, availableForRelease()); } /// @notice the total amount of tokens held by timelock function totalToken() public view override virtual returns (uint256) { return lockedToken.balanceOf(address(this)); } /// @notice amount of tokens released to beneficiary function alreadyReleasedAmount() public view override virtual returns (uint256) { return initialBalance - totalToken(); } /// @notice amount of held tokens unlocked and available for release function availableForRelease() public view override returns (uint256) { uint256 elapsed = timeSinceStart(); uint256 totalAvailable = _proportionAvailable(initialBalance, elapsed, duration); uint256 netAvailable = totalAvailable - alreadyReleasedAmount(); return netAvailable; } /// @notice current beneficiary can appoint new beneficiary, which must be accepted function setPendingBeneficiary(address _pendingBeneficiary) public override onlyBeneficiary { pendingBeneficiary = _pendingBeneficiary; emit PendingBeneficiaryUpdate(_pendingBeneficiary); } /// @notice pending beneficiary accepts new beneficiary function acceptBeneficiary() public override virtual { _setBeneficiary(msg.sender); } function clawback() public balanceCheck { require(msg.sender == clawbackAdmin, "TokenTimelock: Only clawbackAdmin"); if (passedCliff()) { _release(beneficiary, availableForRelease()); } _release(clawbackAdmin, totalToken()); } function passedCliff() public view returns (bool) { return timeSinceStart() >= cliffSeconds; } function _proportionAvailable(uint256 initialBalance, uint256 elapsed, uint256 duration) internal pure virtual returns (uint256); function _setBeneficiary(address newBeneficiary) internal { require( newBeneficiary == pendingBeneficiary, "TokenTimelock: Caller is not pending beneficiary" ); beneficiary = newBeneficiary; emit BeneficiaryUpdate(newBeneficiary); pendingBeneficiary = address(0); } function _setLockedToken(address tokenAddress) internal { lockedToken = IERC20(tokenAddress); } function _release(address to, uint256 amount) internal virtual { lockedToken.transfer(to, amount); emit Release(beneficiary, to, amount); } }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; import "@openzeppelin/contracts/proxy/utils/Initializable.sol"; /// @title an abstract contract for timed events /// @author Fei Protocol abstract contract TimedUpgradeable is Initializable { /// @notice the start timestamp of the timed period uint256 public startTime; /// @notice the duration of the timed period uint256 public duration; event DurationUpdate(uint256 oldDuration, uint256 newDuration); event TimerReset(uint256 startTime); function __Timed_init(uint256 _duration) internal onlyInitializing { __Timed_init_unchained(_duration); } function __Timed_init_unchained(uint256 _duration) internal onlyInitializing { _setDuration(_duration); } modifier duringTime() { require(isTimeStarted(), "Timed: time not started"); require(!isTimeEnded(), "Timed: time ended"); _; } modifier afterTime() { require(isTimeEnded(), "Timed: time not ended"); _; } /// @notice return true if time period has ended function isTimeEnded() public view returns (bool) { return remainingTime() == 0; } /// @notice number of seconds remaining until time is up /// @return remaining function remainingTime() public view returns (uint256) { return duration - timeSinceStart(); // duration always >= timeSinceStart which is on [0,d] } /// @notice number of seconds since contract was initialized /// @return timestamp /// @dev will be less than or equal to duration function timeSinceStart() public view returns (uint256) { if (!isTimeStarted()) { return 0; // uninitialized } uint256 _duration = duration; uint256 timePassed = block.timestamp - startTime; // block timestamp always >= startTime return timePassed > _duration ? _duration : timePassed; } function isTimeStarted() public view returns (bool) { return startTime != 0; } function _initTimed() internal { startTime = block.timestamp; emit TimerReset(block.timestamp); } function _setDuration(uint256 newDuration) internal { require(newDuration != 0, "Timed: zero duration"); uint256 oldDuration = duration; duration = newDuration; emit DurationUpdate(oldDuration, newDuration); } }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.4; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /// @title TokenTimelock interface /// @author Fei Protocol interface ITokenTimelock { // ----------- Events ----------- event Release(address indexed _beneficiary, address indexed _recipient, uint256 _amount); event BeneficiaryUpdate(address indexed _beneficiary); event PendingBeneficiaryUpdate(address indexed _pendingBeneficiary); // ----------- State changing api ----------- function release(address to, uint256 amount) external; function releaseMax(address to) external; function setPendingBeneficiary(address _pendingBeneficiary) external; function acceptBeneficiary() external; // ----------- Getters ----------- function lockedToken() external view returns (IERC20); function beneficiary() external view returns (address); function pendingBeneficiary() external view returns (address); function initialBalance() external view returns (uint256); function availableForRelease() external view returns (uint256); function totalToken() external view returns(uint256); function alreadyReleasedAmount() external view returns (uint256); }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_beneficiary","type":"address"}],"name":"BeneficiaryUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldDuration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"DurationUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_pendingBeneficiary","type":"address"}],"name":"PendingBeneficiaryUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_beneficiary","type":"address"},{"indexed":true,"internalType":"address","name":"_recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Release","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"TimerReset","type":"event"},{"inputs":[],"name":"acceptBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"alreadyReleasedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"availableForRelease","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clawback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clawbackAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cliffSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"address","name":"_lockedToken","type":"address"},{"internalType":"uint256","name":"_cliffDuration","type":"uint256"},{"internalType":"address","name":"_clawbackAdmin","type":"address"},{"internalType":"uint256","name":"_lockedAmount","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isTimeEnded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isTimeStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"passedCliff","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingBeneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"releaseMax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"remainingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingBeneficiary","type":"address"}],"name":"setPendingBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timeSinceStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
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.