Feature Tip: Add private address tag to any address under My Name Tag !
More Info
Private Name Tags
ContractCreator
Latest 15 from a total of 15 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Fund State Chain... | 18897318 | 289 days ago | IN | 0 ETH | 0.00126033 | ||||
Fund State Chain... | 18862122 | 294 days ago | IN | 0 ETH | 0.00122312 | ||||
Fund State Chain... | 18747003 | 310 days ago | IN | 0 ETH | 0.00184599 | ||||
Fund State Chain... | 18733877 | 312 days ago | IN | 0 ETH | 0.0026358 | ||||
Fund State Chain... | 18731026 | 312 days ago | IN | 0 ETH | 0.00307177 | ||||
Fund State Chain... | 18700617 | 317 days ago | IN | 0 ETH | 0.00213869 | ||||
Fund State Chain... | 18635114 | 326 days ago | IN | 0 ETH | 0.00290692 | ||||
Fund State Chain... | 18634904 | 326 days ago | IN | 0 ETH | 0.00251607 | ||||
Fund State Chain... | 18634717 | 326 days ago | IN | 0 ETH | 0.00275405 | ||||
Fund State Chain... | 18634712 | 326 days ago | IN | 0 ETH | 0.0025863 | ||||
Fund State Chain... | 18634708 | 326 days ago | IN | 0 ETH | 0.0024794 | ||||
Fund State Chain... | 18634697 | 326 days ago | IN | 0 ETH | 0.00268402 | ||||
Fund State Chain... | 18634689 | 326 days ago | IN | 0 ETH | 0.00263856 | ||||
Fund State Chain... | 18634651 | 326 days ago | IN | 0 ETH | 0.00269218 | ||||
0x61012060 | 18619763 | 328 days ago | IN | 0 ETH | 0.04093051 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xDE4c128E...C95C67D38 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
TokenVestingStaking
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "Shared.sol"; import "IStateChainGateway.sol"; import "IAddressHolder.sol"; import "ITokenVestingStaking.sol"; import "MockStProvider.sol"; import "SafeERC20.sol"; /** * @title TokenVestingStaking * @dev A token holder contract that that vests its balance of any ERC20 token to the beneficiary. * Validator lockup - stakable. Nothing unlocked until end of contract where everything * unlocks at once. All funds can be staked during the vesting period. * If revoked send all funds to revoker and block beneficiary releases indefinitely. * Any staked funds at the moment of revocation can be retrieved by the revoker upon unstaking. * * The reference to the staking contract is hold by the AddressHolder contract to allow for governance to * update it in case the staking contract needs to be upgraded. * * The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and * is therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). * Therefore, it is recommended to avoid using short time durations (less than a minute). * */ contract TokenVestingStaking is ITokenVestingStaking, Shared { using SafeERC20 for IERC20; // beneficiary of tokens after they are released. It can be transferrable. address private beneficiary; bool public immutable transferableBeneficiary; // the revoker who can cancel the vesting and withdraw any unvested tokens address private revoker; // Durations and timestamps are expressed in UNIX time, the same units as block.timestamp. uint256 public immutable start; uint256 public immutable end; // solhint-disable-next-line var-name-mixedcase IERC20 public immutable FLIP; // The contract that holds the reference addresses for staking purposes. IAddressHolder public immutable addressHolder; bool public revoked; // Cumulative counter for amount staked to the st provider uint256 public stTokenStaked; // Cumulative counter for amount unstaked from the st provider uint256 public stTokenUnstaked; /** * @param beneficiary_ address of the beneficiary to whom vested tokens are transferred * @param revoker_ the person with the power to revoke the vesting. Address(0) means it is not revocable. * @param start_ the unix time when the beneficiary can start staking the tokens. * @param end_ the unix time of the end of the vesting period, everything withdrawable after * @param transferableBeneficiary_ whether the beneficiary address can be transferred * @param addressHolder_ the contract holding the reference address to the ScGateway for staking * @param flip_ the FLIP token address. */ constructor( address beneficiary_, address revoker_, uint256 start_, uint256 end_, bool transferableBeneficiary_, IAddressHolder addressHolder_, IERC20 flip_ ) nzAddr(beneficiary_) nzAddr(address(addressHolder_)) nzAddr(address(flip_)) { require(start_ <= end_, "Vesting: start_ after end_"); require(block.timestamp < start_, "Vesting: start before current time"); beneficiary = beneficiary_; revoker = revoker_; start = start_; end = end_; transferableBeneficiary = transferableBeneficiary_; addressHolder = addressHolder_; FLIP = flip_; } ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// /** * @notice Funds an account in the statechain with some tokens for the nodeID * and forces the return address of that to be this contract. * @param nodeID the nodeID to fund. * @param amount the amount of FLIP out of the current funds in this contract. */ function fundStateChainAccount( bytes32 nodeID, uint256 amount ) external override onlyBeneficiary notRevoked afterStart { address stateChainGateway = addressHolder.getStateChainGateway(); FLIP.approve(stateChainGateway, amount); IStateChainGateway(stateChainGateway).fundStateChainAccount(nodeID, amount); } /** * @notice Stakes to the staking provider by transferring an amount of FLIP to the staking minter. * It is expected that an amount of stFLIP will be minted to this contract. * @param amount the amount of FLIP to stake to the staking provider. */ function stakeToStProvider(uint256 amount) external override onlyBeneficiary notRevoked afterStart { address stMinter = addressHolder.getStakingAddress(); FLIP.approve(stMinter, amount); stTokenStaked += amount; require(IMinter(stMinter).mint(address(this), amount)); } /** * @notice Unstakes from the staking provider by transferring stFLIP to the staking burner. * @param amount the amount of FLIP to stake to the staking provider. */ function unstakeFromStProvider(uint256 amount) external override onlyBeneficiary notRevoked returns (uint256) { (address stBurner, address stFlip) = addressHolder.getUnstakingAddresses(); IERC20(stFlip).approve(stBurner, amount); stTokenUnstaked += amount; return IBurner(stBurner).burn(address(this), amount); } /** * @notice Claims the liquid staking provider rewards. * @param amount_ the amount of rewards to claim. If greater than `totalRewards`, then all rewards are claimed. * @dev `stTokenCounter` updates after staking/unstaking operation to keep track of the st token principle. Any * amount above the principle is considered rewards and thus can be claimed by the beneficiary. */ function claimStProviderRewards(uint256 amount_) external override onlyBeneficiary notRevoked { address stFlip = addressHolder.getStFlip(); uint256 totalRewards = stFLIP(stFlip).balanceOf(address(this)) + stTokenUnstaked - stTokenStaked; uint256 amount = amount_ > totalRewards ? totalRewards : amount_; stFLIP(stFlip).transfer(beneficiary, amount); } /** * @notice Transfers vested tokens to beneficiary. * @param token ERC20 token which is being vested. */ function release(IERC20 token) external override onlyBeneficiary notRevoked { uint256 unreleased = _releasableAmount(token); require(unreleased > 0, "Vesting: no tokens are due"); emit TokensReleased(token, unreleased); token.safeTransfer(beneficiary, unreleased); } /** * @notice Allows the revoker to revoke the vesting and stop the beneficiary from releasing any * tokens if the vesting period has not been completed. Any staked tokens at the time of * revoking can be retrieved by the revoker upon unstaking via `retrieveRevokedFunds`. * @param token ERC20 token which is being vested. */ function revoke(IERC20 token) external override onlyRevoker notRevoked { require(block.timestamp <= end, "Vesting: vesting expired"); uint256 balance = token.balanceOf(address(this)); uint256 unreleased = _releasableAmount(token); uint256 refund = balance - unreleased; revoked = true; token.safeTransfer(revoker, refund); emit TokenVestingRevoked(token, refund); } /** * @notice Allows the revoker to retrieve tokens that have been unstaked after the revoke * function has been called. Safeguard mechanism in case of unstaking happening * after revoke, otherwise funds would be locked. * @param token ERC20 token which is being vested. */ function retrieveRevokedFunds(IERC20 token) external override onlyRevoker { require(revoked, "Vesting: token not revoked"); uint256 balance = token.balanceOf(address(this)); token.safeTransfer(revoker, balance); } /** * @dev Calculates the amount that has already vested but hasn't been released yet. * @param token ERC20 token which is being vested. */ function _releasableAmount(IERC20 token) private view returns (uint256) { return block.timestamp < end ? 0 : token.balanceOf(address(this)); } /// @dev Allow the beneficiary to be transferred to a new address if needed function transferBeneficiary(address beneficiary_) external override onlyBeneficiary nzAddr(beneficiary_) { require(transferableBeneficiary, "Vesting: beneficiary not transferrable"); emit BeneficiaryTransferred(beneficiary, beneficiary_); beneficiary = beneficiary_; } /// @dev Allow the revoker to be transferred to a new address if needed function transferRevoker(address revoker_) external override onlyRevoker nzAddr(revoker_) { emit RevokerTransferred(revoker, revoker_); revoker = revoker_; } ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// /** * @return the beneficiary address */ function getBeneficiary() external view override returns (address) { return beneficiary; } /** * @return the revoker address */ function getRevoker() external view override returns (address) { return revoker; } ////////////////////////////////////////////////////////////// // // // Modifiers // // // ////////////////////////////////////////////////////////////// /** * @dev Ensure that the caller is the beneficiary address */ modifier onlyBeneficiary() { require(msg.sender == beneficiary, "Vesting: not the beneficiary"); _; } /** * @dev Ensure that the caller is the revoker address */ modifier onlyRevoker() { require(msg.sender == revoker, "Vesting: not the revoker"); _; } modifier notRevoked() { require(!revoked, "Vesting: token revoked"); _; } modifier afterStart() { require(block.timestamp >= start, "Vesting: not started"); _; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IShared.sol"; /** * @title Shared contract * @notice Holds constants and modifiers that are used in multiple contracts * @dev It would be nice if this could be a library, but modifiers can't be exported :( */ abstract contract Shared is IShared { /// @dev The address used to indicate whether transfer should send native or a token address internal constant _NATIVE_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address internal constant _ZERO_ADDR = address(0); bytes32 internal constant _NULL = ""; uint256 internal constant _E_18 = 1e18; /// @dev Checks that a uint isn't zero/empty modifier nzUint(uint256 u) { require(u != 0, "Shared: uint input is empty"); _; } /// @dev Checks that an address isn't zero/empty modifier nzAddr(address a) { require(a != _ZERO_ADDR, "Shared: address input is empty"); _; } /// @dev Checks that a bytes32 isn't zero/empty modifier nzBytes32(bytes32 b) { require(b != _NULL, "Shared: bytes32 input is empty"); _; } /// @dev Checks that the pubKeyX is populated modifier nzKey(Key memory key) { require(key.pubKeyX != 0, "Shared: pubKeyX is empty"); _; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IERC20.sol"; /** * @title Shared interface * @notice Holds structs needed by other interfaces */ interface IShared { /** * @dev SchnorrSECP256K1 requires that each key has a public key part (x coordinate), * a parity for the y coordinate (0 if the y ordinate of the public key is even, 1 * if it's odd) */ struct Key { uint256 pubKeyX; uint8 pubKeyYParity; } /** * @dev Contains a signature and the nonce used to create it. Also the recovered address * to check that the signature is valid */ struct SigData { uint256 sig; uint256 nonce; address kTimesGAddress; } /** * @param token The address of the token to be transferred * @param recipient The address of the recipient of the transfer * @param amount The amount to transfer, in wei (uint) */ struct TransferParams { address token; address payable recipient; uint256 amount; } /** * @param swapID The unique identifier for this swap (bytes32), used for create2 * @param token The token to be transferred */ struct DeployFetchParams { bytes32 swapID; address token; } /** * @param fetchContract The address of the deployed Deposit contract * @param token The token to be transferred */ struct FetchParams { address payable fetchContract; address token; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev 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); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IFLIP.sol"; import "IAggKeyNonceConsumer.sol"; import "IGovernanceCommunityGuarded.sol"; import "IFlipIssuer.sol"; /** * @title StateChainGateway interface */ interface IStateChainGateway is IGovernanceCommunityGuarded, IFlipIssuer, IAggKeyNonceConsumer { event Funded(bytes32 indexed nodeID, uint256 amount, address funder); event RedemptionRegistered( bytes32 indexed nodeID, uint256 amount, address indexed redeemAddress, uint48 startTime, uint48 expiryTime, address executor ); event RedemptionExecuted(bytes32 indexed nodeID, uint256 amount); event RedemptionExpired(bytes32 indexed nodeID, uint256 amount); event MinFundingChanged(uint256 oldMinFunding, uint256 newMinFunding); event GovernanceWithdrawal(address to, uint256 amount); event FLIPSet(address flip); event FlipSupplyUpdated(uint256 oldSupply, uint256 newSupply, uint256 stateChainBlockNumber); struct Redemption { uint256 amount; address redeemAddress; // 48 so that 160 (from redeemAddress) + 48 + 48 is 256 they can all be packed // into a single 256 bit slot uint48 startTime; uint48 expiryTime; address executor; } /** * @notice Sets the FLIP address after initialization. We can't do this in the constructor * because FLIP contract requires this contract's address on deployment for minting. * First this contract is deployed, then the FLIP contract and finally setFLIP * should be called. OnlyDeployer modifer for added security since tokens will be * minted to this contract before calling setFLIP. * @param flip FLIP token address */ function setFlip(IFLIP flip) external; /** * @notice Add FLIP funds to a StateChain account identified with a nodeID * @dev Requires the funder to have called `approve` in FLIP * @param amount The amount of FLIP tokens * @param nodeID The nodeID of the account to fund */ function fundStateChainAccount(bytes32 nodeID, uint256 amount) external; /** * @notice Redeem FLIP from the StateChain. The State Chain will determine the amount * that can be redeemed, but a basic calculation for a validator would be: * amount redeemable = stake + rewards - penalties. * @param sigData Struct containing the signature data over the message * to verify, signed by the aggregate key. * @param nodeID The nodeID of the account redeeming the FLIP * @param amount The amount of funds to be locked up * @param redeemAddress The redeemAddress who will receive the FLIP * @param expiryTime The last valid timestamp that can execute this redemption (uint48) */ function registerRedemption( SigData calldata sigData, bytes32 nodeID, uint256 amount, address redeemAddress, uint48 expiryTime, address executor ) external; /** * @notice Execute a pending redemption to get back funds. Cannot execute a pending * redemption before 48h have passed after registering it, or after the specified * expiry time * @dev No need for nzUint(nodeID) since that is handled by `redemption.expiryTime > 0` * @param nodeID The nodeID of the account redeeming the FLIP * @return The address that received the FLIP and the amount */ function executeRedemption(bytes32 nodeID) external returns (address, uint256); /** * @notice Compares a given new FLIP supply against the old supply and mints or burns * FLIP tokens from this contract as appropriate. * It requires a message signed by the aggregate key. * @param sigData Struct containing the signature data over the message * to verify, signed by the aggregate key. * @param newTotalSupply new total supply of FLIP * @param stateChainBlockNumber State Chain block number for the new total supply */ function updateFlipSupply(SigData calldata sigData, uint256 newTotalSupply, uint256 stateChainBlockNumber) external; /** * @notice Updates the address that is allowed to issue FLIP tokens. This will be used when this * contract needs an upgrade. A new contract will be deployed and all the FLIP will be * transferred to it via the redemption process. Finally the right to issue FLIP will be transferred. * @param sigData Struct containing the signature data over the message * to verify, signed by the aggregate key. * @param newIssuer New contract that will issue FLIP tokens. * @param omitChecks Allow the omission of the extra checks in a special case */ function updateFlipIssuer(SigData calldata sigData, address newIssuer, bool omitChecks) external; /** * @notice Set the minimum amount of funds needed for `fundStateChainAccount` to be able * to be called. Used to prevent spamming of funding. * @param newMinFunding The new minimum funding amount */ function setMinFunding(uint256 newMinFunding) external; /** * @notice Withdraw all FLIP to governance address in case of emergency. This withdrawal needs * to be approved by the Community, it is a last resort. Used to rectify an emergency. * The governance address is also updated as the issuer of FLIP. */ function govWithdraw() external; /** * @notice Update the FLIP Issuer address with the governance address in case of emergency. * This needs to be approved by the Community, it is a last resort. Used to rectify * an emergency. */ function govUpdateFlipIssuer() external; ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// /** * @notice Get the minimum amount of funds that's required for funding * an account on the StateChain. * @return The minimum amount (uint) */ function getMinimumFunding() external view returns (uint256); /** * @notice Get the pending redemption for the input nodeID. If there was never * a pending redemption for this nodeID, or it has already been executed * (and therefore deleted), it'll return (0, 0x00..., 0, 0) * @param nodeID The nodeID which has a pending redemption * @return The redemption (Redemption struct) */ function getPendingRedemption(bytes32 nodeID) external view returns (Redemption memory); /** * @notice Get the last state chain block number that the supply was updated at * @return The state chain block number of the last update */ function getLastSupplyUpdateBlockNumber() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IERC20.sol"; /** * @title FLIP interface for the FLIP utility token */ interface IFLIP is IERC20 { event IssuerUpdated(address oldIssuer, address newIssuer); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// function mint(address account, uint amount) external; function burn(address account, uint amount) external; function updateIssuer(address newIssuer) external; ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// function getIssuer() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IShared.sol"; import "IKeyManager.sol"; /** * @title AggKeyNonceConsumer interface */ interface IAggKeyNonceConsumer is IShared { event UpdatedKeyManager(address keyManager); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// /** * @notice Update KeyManager reference. Used if KeyManager contract is updated * @param sigData Struct containing the signature data over the message * to verify, signed by the aggregate key. * @param keyManager New KeyManager's address * @param omitChecks Allow the omission of the extra checks in a special case */ function updateKeyManager(SigData calldata sigData, IKeyManager keyManager, bool omitChecks) external; ////////////////////////////////////////////////////////////// // // // Getters // // // ////////////////////////////////////////////////////////////// /** * @notice Get the KeyManager address/interface that's used to validate sigs * @return The KeyManager (IKeyManager) */ function getKeyManager() external view returns (IKeyManager); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IShared.sol"; /** * @title KeyManager interface * @notice The interface for functions KeyManager implements */ interface IKeyManager is IShared { event AggKeySetByAggKey(Key oldAggKey, Key newAggKey); event AggKeySetByGovKey(Key oldAggKey, Key newAggKey); event GovKeySetByAggKey(address oldGovKey, address newGovKey); event GovKeySetByGovKey(address oldGovKey, address newGovKey); event CommKeySetByAggKey(address oldCommKey, address newCommKey); event CommKeySetByCommKey(address oldCommKey, address newCommKey); event SignatureAccepted(SigData sigData, address signer); event GovernanceAction(bytes32 message); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// function consumeKeyNonce(SigData memory sigData, bytes32 contractMsgHash) external; function setAggKeyWithAggKey(SigData memory sigData, Key memory newAggKey) external; function setAggKeyWithGovKey(Key memory newAggKey) external; function setGovKeyWithAggKey(SigData calldata sigData, address newGovKey) external; function setGovKeyWithGovKey(address newGovKey) external; function setCommKeyWithAggKey(SigData calldata sigData, address newCommKey) external; function setCommKeyWithCommKey(address newCommKey) external; function govAction(bytes32 message) external; ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// function getAggregateKey() external view returns (Key memory); function getGovernanceKey() external view returns (address); function getCommunityKey() external view returns (address); function isNonceUsedByAggKey(uint256 nonce) external view returns (bool); function getLastValidateTime() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IShared.sol"; /** * @title GovernanceCommunityGuarded interface */ interface IGovernanceCommunityGuarded is IShared { event CommunityGuardDisabled(bool communityGuardDisabled); event Suspended(bool suspended); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// /** * @notice Enable Community Guard */ function enableCommunityGuard() external; /** * @notice Disable Community Guard */ function disableCommunityGuard() external; /** * @notice Can be used to suspend contract execution - only executable by * governance and only to be used in case of emergency. */ function suspend() external; /** * @notice Resume contract execution */ function resume() external; ////////////////////////////////////////////////////////////// // // // Getters // // // ////////////////////////////////////////////////////////////// /** * @notice Get the Community Key * @return The CommunityKey */ function getCommunityKey() external view returns (address); /** * @notice Get the Community Guard state * @return The Community Guard state */ function getCommunityGuardDisabled() external view returns (bool); /** * @notice Get suspended state * @return The suspended state */ function getSuspendedState() external view returns (bool); /** * @notice Get governor address * @return The governor address */ function getGovernor() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IFLIP.sol"; /** * @title Flip Issuer interface * @notice This interface is required when updating the FLIP issuer. * Additionally, any contract inheriting this should implement the * mint and burn capabilities to interact with the FLIP contract. */ interface IFlipIssuer { /** * @notice Get the FLIP token address * @return The address of FLIP */ function getFLIP() external view returns (IFLIP); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IAddressHolder { event StateChainGatewayUpdated(address oldStateChainGateway, address newStateChainGateway); event StakingAddressesUpdated( address oldStMinter, address oldStBurner, address oldStFLIP, address newStMinter, address newStBurner, address newStFLIP ); event GovernorTransferred(address oldGovernor, address newGovernor); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// function updateStateChainGateway(address _stateChainGateway) external; function updateStakingAddresses(address _stMinter, address _stBurner, address _stFLIP) external; function transferGovernor(address _governor) external; ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// function getStateChainGateway() external view returns (address); function getStakingAddress() external view returns (address); function getUnstakingAddresses() external view returns (address, address); function getStFlip() external view returns (address); function getGovernor() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "SafeERC20.sol"; interface ITokenVestingStaking { event TokensReleased(IERC20 indexed token, uint256 amount); event TokenVestingRevoked(IERC20 indexed token, uint256 refund); event BeneficiaryTransferred(address oldBeneficiary, address newBeneficiary); event RevokerTransferred(address oldRevoker, address newRevoker); ////////////////////////////////////////////////////////////// // // // State-changing functions // // // ////////////////////////////////////////////////////////////// function fundStateChainAccount(bytes32 nodeID, uint256 amount) external; function stakeToStProvider(uint256 amount) external; function unstakeFromStProvider(uint256 amount) external returns (uint256); function claimStProviderRewards(uint256 amount_) external; function release(IERC20 token) external; function revoke(IERC20 token) external; function retrieveRevokedFunds(IERC20 token) external; function transferBeneficiary(address beneficiary_) external; function transferRevoker(address revoker_) external; ////////////////////////////////////////////////////////////// // // // Non-state-changing functions // // // ////////////////////////////////////////////////////////////// function getBeneficiary() external view returns (address); function getRevoker() external view returns (address); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "IERC20.sol"; import "draft-IERC20Permit.sol"; import "Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit 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(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.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 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 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) { (bool success, bytes memory returndata) = target.delegatecall(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); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "ERC20.sol"; interface IMinter { function mint(address to, uint256 amount) external returns (bool); } interface IBurner { function burn(address to, uint256 amount) external returns (uint256); } contract Minter is IMinter { stFLIP public stflip; IERC20 public flip; address public output; constructor(address _stflip, address _flip, address _output) { stflip = stFLIP(_stflip); flip = IERC20(_flip); output = address(_output); } function mint(address to, uint256 amount) external returns (bool) { // require(stflip.minter() == address(this), "this is not a valid mint contract"); flip.transferFrom(msg.sender, output, amount); _mint(to, amount); return true; } function _mint(address to, uint256 amount) internal { stflip.mint(to, amount); // emit Mint(to, amount); } } contract Burner is IBurner { stFLIP public stflip; IERC20 public flip; struct Burn { address user; uint256 amount; bool completed; } Burn[] public burns; constructor(address _stflip, address _flip) { stflip = stFLIP(_stflip); flip = IERC20(_flip); } // NOTE: Burn & Redeem functions are simplified for the sake of testing function burn(address to, uint256 amount) external returns (uint256) { stflip.transferFrom(msg.sender, address(this), amount); burns.push(Burn(to, amount, false)); stflip.burn(amount, address(this)); return burns.length - 1; } function redeem(uint256 burnId) external { require(burns[burnId].completed == false, "completed"); // Audit: Cache the burns[Burnid] burns[burnId].completed = true; flip.transfer(burns[burnId].user, burns[burnId].amount); } } // solhint-disable-next-line contract-name-camelcase contract stFLIP is ERC20 { address public minter; address public burner; event Burn(address from, uint256 amount, address refundee); constructor() ERC20("StakedFLIP", "stFLIP") {} function initialize(address _minter, address _burner) public { require(minter == address(0) && burner == address(0), "already initialized"); minter = _minter; burner = _burner; } function mint(address to, uint256 amount) public { require(msg.sender == minter, "only minter can mint"); _mint(to, amount); } function burn(uint256 value, address refundee) public { require(msg.sender == burner, "only burner can burn"); emit Burn(msg.sender, value, refundee); _burn(msg.sender, value); } function mockSlash(address account, uint256 amount) public { _burn(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "IERC20.sol"; import "IERC20Metadata.sol"; import "Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
{ "evmVersion": "paris", "optimizer": { "enabled": true, "runs": 100 }, "libraries": { "TokenVestingStaking.sol": {} }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"beneficiary_","type":"address"},{"internalType":"address","name":"revoker_","type":"address"},{"internalType":"uint256","name":"start_","type":"uint256"},{"internalType":"uint256","name":"end_","type":"uint256"},{"internalType":"bool","name":"transferableBeneficiary_","type":"bool"},{"internalType":"contract IAddressHolder","name":"addressHolder_","type":"address"},{"internalType":"contract IERC20","name":"flip_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldBeneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"newBeneficiary","type":"address"}],"name":"BeneficiaryTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldRevoker","type":"address"},{"indexed":false,"internalType":"address","name":"newRevoker","type":"address"}],"name":"RevokerTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"refund","type":"uint256"}],"name":"TokenVestingRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"inputs":[],"name":"FLIP","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addressHolder","outputs":[{"internalType":"contract IAddressHolder","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"claimStProviderRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"nodeID","type":"bytes32"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"fundStateChainAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getBeneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRevoker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"retrieveRevokedFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"revoke","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stTokenStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stTokenUnstaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stakeToStProvider","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary_","type":"address"}],"name":"transferBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"revoker_","type":"address"}],"name":"transferRevoker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferableBeneficiary","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstakeFromStProvider","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $0.99341 | 0.3682 | $0.3657 |
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.