Contract

0x82Ad58A16EdDa7F13FB7AdC3CA71b0D5FC1CF89C

Feature Tip: Add private address tag to any address under My Name Tag !

Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

0x0050FAE6...691ad8E7C at txn 0xd277875cf1054ec7e0d1ac95ad8ac8d9f695390ae1aa6e860d34e82b8d2ec652

Multichain Info

$0 (Multichain Portfolio)

	Transaction Hash	Method	Block		From		To
There are no matching entries Please try again later

Latest 1 internal transaction

Advanced mode:

Parent Transaction Hash	Block		From		To
0xd277875cf1054ec7e0d1ac95ad8ac8d9f695390ae1aa6e860d34e82b8d2ec652	11808549	2021-02-07 9:47:52	1365 days ago	1612691272	0xf0159d04...c7088030b		Contract Creation	0 ETH$0.00

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x62ef495c...E75f25830
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:

TimeLock

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 999999 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-02-09
*/

// SPDX-License-Identifier: SEE LICENSE IN LICENSE

pragma abicoder v2;
pragma solidity >=0.7.6;

interface IStakePoolCreator {
    function version() external returns (uint256);

    function create() external returns (address);

    function initialize(
        address poolAddress,
        address pair,
        address rewardToken,
        address timelock,
        address stakePoolRewardFund,
        bytes calldata data
    ) external;
}

interface IStakePoolController {
    event MasterCreated(address indexed farm, address indexed pair, uint256 version, address timelock, address stakePoolRewardFund, uint256 totalStakePool);
    event SetWhitelistStakingFor(address indexed contractAddress, bool value);
    event SetWhitelistStakePool(address indexed contractAddress, int8 value);
    event SetStakePoolCreator(address indexed contractAddress, uint256 verion);
    event SetWhitelistRewardRebaser(address indexed contractAddress, bool value);
    event SetWhitelistRewardMultiplier(address indexed contractAddress, bool value);
    event SetStakePoolVerifier(address indexed contractAddress, bool value);
    event ChangeGovernance(address indexed governance);
    event SetFeeCollector(address indexed feeCollector);
    event SetFeeToken(address indexed token);
    event SetFeeAmount(uint256 indexed amount);

    function allStakePools(uint256) external view returns (address stakePool);

    function isStakePool(address contractAddress) external view returns (bool);

    function isStakePoolVerifier(address contractAddress) external view returns (bool);

    function isWhitelistStakingFor(address contractAddress) external view returns (bool);

    function isWhitelistStakePool(address contractAddress) external view returns (int8);

    function setStakePoolVerifier(address contractAddress, bool state) external;

    function setWhitelistStakingFor(address contractAddress, bool state) external;

    function setWhitelistStakePool(address contractAddress, int8 state) external;

    function addStakePoolCreator(address contractAddress) external;

    function isWhitelistRewardRebaser(address contractAddress) external view returns (bool);

    function isAllowEmergencyWithdrawStakePool(address _address) external view returns (bool);

    function setWhitelistRewardRebaser(address contractAddress, bool state) external;

    function isWhitelistRewardMultiplier(address contractAddress) external view returns (bool);

    function setAllowEmergencyWithdrawStakePool(address _address, bool state) external;

    function setWhitelistRewardMultiplier(address contractAddress, bool state) external;

    function setEnableWhitelistRewardRebaser(bool value) external;

    function setEnableWhitelistRewardMultiplier(bool value) external;

    function allStakePoolsLength() external view returns (uint256);

    function create(
        uint256 version,
        address pair,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata data,
        uint8 flag
    ) external returns (address);

    function createPair(
        uint256 version,
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata poolRewardInfo,
        uint8 flag
    ) external returns (address);

    function setGovernance(address) external;

    function setFeeCollector(address _address) external;

    function setFeeToken(address _token) external;

    function setFeeAmount(uint256 _token) external;
}

interface IValueLiquidRouter {
    struct Swap {
        address pool;
        address tokenIn;
        address tokenOut;
        uint256 swapAmount; // tokenInAmount / tokenOutAmount
        uint256 limitReturnAmount; // minAmountOut / maxAmountIn
        uint256 maxPrice;
        bool isBPool;
    }

    function factory() external view returns (address);

    function controller() external view returns (address);

    function formula() external view returns (address);

    function WETH() external view returns (address);

    function addLiquidity(
        address pair,
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address pair,
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function swapExactTokensForTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        address tokenOut,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        address tokenIn,
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        address tokenOut,
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256[] memory amounts);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        address tokenOut,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external;

    function addStakeLiquidity(
        address stakePool,
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addStakeLiquidityETH(
        address stakePool,
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function multihopBatchSwapExactIn(
        Swap[][] memory swapSequences,
        address tokenIn,
        address tokenOut,
        uint256 totalAmountIn,
        uint256 minTotalAmountOut,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256 totalAmountOut);

    function multihopBatchSwapExactOut(
        Swap[][] memory swapSequences,
        address tokenIn,
        address tokenOut,
        uint256 maxTotalAmountIn,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256 totalAmountIn);

    function createPair(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint32 tokenWeightA,
        uint32 swapFee,
        address to,
        uint8 flag
    ) external returns (uint256 liquidity);

    function createPairETH(
        address token,
        uint256 amountToken,
        uint32 tokenWeight,
        uint32 swapFee,
        address to,
        uint8 flag
    ) external payable returns (uint256 liquidity);
}

interface IValueLiquidFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint32 tokenWeight0, uint32 swapFee, uint256);

    function feeTo() external view returns (address);

    function formula() external view returns (address);

    function protocolFee() external view returns (uint256);

    function feeToSetter() external view returns (address);

    function getPair(
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee
    ) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function isPair(address) external view returns (bool);

    function allPairsLength() external view returns (uint256);

    function createPair(
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee
    ) external returns (address pair);

    function getWeightsAndSwapFee(address pair)
        external
        view
        returns (
            uint32 tokenWeight0,
            uint32 tokenWeight1,
            uint32 swapFee
        );

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function setProtocolFee(uint256) external;
}

interface IStakePool {
    event Deposit(address indexed account, uint256 amount);
    event AddRewardPool(uint256 indexed poolId);
    event UpdateRewardPool(uint256 indexed poolId, uint256 endRewardBlock, uint256 rewardPerBlock);
    event PayRewardPool(
        uint256 indexed poolId,
        address indexed rewardToken,
        address indexed account,
        uint256 pendingReward,
        uint256 rebaseAmount,
        uint256 paidReward
    );
    event UpdateRewardRebaser(uint256 indexed poolId, address rewardRebaser);
    event UpdateRewardMultiplier(uint256 indexed poolId, address rewardMultiplier);
    event Withdraw(address indexed account, uint256 amount);

    function version() external returns (uint256);

    function pair() external returns (address);

    function initialize(
        address _pair,
        uint256 _unstakingFrozenTime,
        address _rewardFund,
        address _timelock
    ) external;

    function stake(uint256) external;

    function stakeFor(address _account) external;

    function withdraw(uint256) external;

    function getReward(uint8 _pid, address _account) external;

    function getAllRewards(address _account) external;

    function claimReward() external;

    function pendingReward(uint8 _pid, address _account) external view returns (uint256);

    function allowRecoverRewardToken(address _token) external returns (bool);

    function getRewardPerBlock(uint8 pid) external view returns (uint256);

    function rewardPoolInfoLength() external view returns (uint256);

    function unfrozenStakeTime(address _account) external view returns (uint256);

    function emergencyWithdraw() external;

    function updateReward() external;

    function updateReward(uint8 _pid) external;

    function updateRewardPool(
        uint8 _pid,
        uint256 _endRewardBlock,
        uint256 _rewardPerBlock
    ) external;

    function getRewardMultiplier(
        uint8 _pid,
        uint256 _from,
        uint256 _to,
        uint256 _rewardPerBlock
    ) external view returns (uint256);

    function getRewardRebase(
        uint8 _pid,
        address _rewardToken,
        uint256 _pendingReward
    ) external view returns (uint256);

    function updateRewardRebaser(uint8 _pid, address _rewardRebaser) external;

    function updateRewardMultiplier(uint8 _pid, address _rewardMultiplier) external;

    function getUserInfo(uint8 _pid, address _account)
        external
        view
        returns (
            uint256 amount,
            uint256 rewardDebt,
            uint256 accumulatedEarned,
            uint256 lockReward,
            uint256 lockRewardReleased
        );

    function addRewardPool(
        address _rewardToken,
        address _rewardRebaser,
        address _rewardMultiplier,
        uint256 _startBlock,
        uint256 _endRewardBlock,
        uint256 _rewardPerBlock,
        uint256 _lockRewardPercent,
        uint256 _startVestingBlock,
        uint256 _endVestingBlock
    ) external;

    function removeLiquidity(
        address provider,
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);
}

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: APPROVE_FAILED");
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FAILED");
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FROM_FAILED");
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "TransferHelper: ETH_TRANSFER_FAILED");
    }
}

interface IValueLiquidPair {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event PaidProtocolFee(uint112 collectedFee0, uint112 collectedFee1);
    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function getCollectedFees() external view returns (uint112 _collectedFee0, uint112 _collectedFee1);

    function getTokenWeights() external view returns (uint32 tokenWeight0, uint32 tokenWeight1);

    function getSwapFee() external view returns (uint32);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(
        address,
        address,
        uint32,
        uint32
    ) external;
}

// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, "ds-math-add-overflow");
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x, "ds-math-sub-underflow");
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
        require(b > 0, "ds-math-division-by-zero");
        c = a / b;
    }
}

contract TimeLock {
    using SafeMath for uint256;
    event NewAdmin(address indexed newAdmin);
    event NewPendingAdmin(address indexed newPendingAdmin);
    event NewDelay(uint256 indexed newDelay);
    event CancelTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);
    event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);
    event QueueTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);

    uint256 public constant GRACE_PERIOD = 14 days;
    uint256 public constant MINIMUM_DELAY = 1 days;
    uint256 public constant MAXIMUM_DELAY = 30 days;
    bool private _initialized;
    address public admin;
    address public pendingAdmin;
    uint256 public delay;
    bool public admin_initialized;
    mapping(bytes32 => bool) public queuedTransactions;

    constructor() {
        admin_initialized = false;
        _initialized = false;
    }

    function initialize(address _admin, uint256 _delay) public {
        require(_initialized == false, "Timelock::constructor: Initialized must be false.");
        require(_delay >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(_delay <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = _delay;
        admin = _admin;
        _initialized = true;
        emit NewAdmin(admin);
        emit NewDelay(delay);
    }

    receive() external payable {}

    function setDelay(uint256 _delay) public {
        require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
        require(_delay >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(_delay <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = _delay;
        emit NewDelay(delay);
    }

    function acceptAdmin() public {
        require(msg.sender == pendingAdmin, "Timelock::acceptAdmin: Call must come from pendingAdmin.");
        admin = msg.sender;
        pendingAdmin = address(0);
        emit NewAdmin(admin);
    }

    function setPendingAdmin(address _pendingAdmin) public {
        // allows one time setting of admin for deployment purposes
        if (admin_initialized) {
            require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
        } else {
            require(msg.sender == admin, "Timelock::setPendingAdmin: First call must come from admin.");
            admin_initialized = true;
        }
        pendingAdmin = _pendingAdmin;

        emit NewPendingAdmin(pendingAdmin);
    }

    function queueTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public returns (bytes32) {
        require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
        require(eta >= getBlockTimestamp().add(delay), "Timelock::queueTransaction: Estimated execution block must satisfy delay.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = true;

        emit QueueTransaction(txHash, target, value, signature, data, eta);
        return txHash;
    }

    function cancelTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public {
        require(msg.sender == admin, "Timelock::cancelTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = false;

        emit CancelTransaction(txHash, target, value, signature, data, eta);
    }

    function executeTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public payable returns (bytes memory) {
        require(msg.sender == admin, "Timelock::executeTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
        require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
        require(getBlockTimestamp() <= eta.add(GRACE_PERIOD), "Timelock::executeTransaction: Transaction is stale.");

        queuedTransactions[txHash] = false;

        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }

        // solium-disable-next-line security/no-call-value
        (bool success, bytes memory returnData) = target.call{value: value}(callData);
        require(success, "Timelock::executeTransaction: Transaction execution reverted.");

        emit ExecuteTransaction(txHash, target, value, signature, data, eta);

        return returnData;
    }

    function getBlockTimestamp() internal view returns (uint256) {
        return block.timestamp;
    }
}

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

interface IStakePoolRewardFund {
    function initialize(address _stakePool, address _timelock) external;

    function safeTransfer(
        address _token,
        address _to,
        uint256 _value
    ) external;
}

interface IStakePoolRewardRebaser {
    function getRebaseAmount(address rewardToken, uint256 baseAmount) external view returns (uint256);
}

interface IStakePoolRewardMultiplier {
    function getRewardMultiplier(
        uint256 _start,
        uint256 _end,
        uint256 _from,
        uint256 _to,
        uint256 _rewardPerBlock
    ) external view returns (uint256);
}

contract StakePoolRewardFund is IStakePoolRewardFund {
    uint256 public constant BLOCKS_PER_DAY = 6528;
    address public stakePool;
    address public timelock;
    bool private _initialized;

    function initialize(address _stakePool, address _timelock) external override {
        require(_initialized == false, "StakePoolRewardFund: already initialized");
        stakePool = _stakePool;
        timelock = _timelock;
        _initialized = true;
    }

    function safeTransfer(
        address _token,
        address _to,
        uint256 _value
    ) external override {
        require(msg.sender == stakePool, "StakePoolRewardFund: !stakePool");
        TransferHelper.safeTransfer(_token, _to, _value);
    }

    function recoverRewardToken(
        address _token,
        uint256,
        address
    ) external {
        require(msg.sender == timelock, "StakePoolRewardFund: !timelock");
        require(IStakePool(stakePool).allowRecoverRewardToken(_token), "StakePoolRewardFund: not allow recover reward token");
    }
}

interface IFreeFromUpTo {
    function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
}

contract StakePoolController is IStakePoolController {
    IValueLiquidFactory public swapFactory;
    address public governance;

    address public feeCollector;
    address public feeToken;
    uint256 public feeAmount;

    mapping(address => bool) private _stakePools;
    mapping(address => bool) private _whitelistStakingFor;
    mapping(address => bool) private _whitelistRewardRebaser;
    mapping(address => bool) private _whitelistRewardMultiplier;
    mapping(address => int8) private _whitelistStakePools;
    mapping(address => bool) public _stakePoolVerifiers;
    mapping(uint256 => address) public stakePoolCreators;
    address[] public override allStakePools;
    bool public enableWhitelistRewardRebaser = true;
    bool public enableWhitelistRewardMultiplier = true;
    bool private _initialized = false;

    IFreeFromUpTo public constant chi = IFreeFromUpTo(0x0000000000004946c0e9F43F4Dee607b0eF1fA1c);
    mapping(address => bool) public allowEmergencyWithdrawStakePools;

    modifier discountCHI(uint8 flag) {
        uint256 gasStart = gasleft();
        _;
        if ((flag & 0x1) == 1) {
            uint256 gasSpent = 21000 + gasStart - gasleft() + 16 * msg.data.length;
            chi.freeFromUpTo(msg.sender, (gasSpent + 14154) / 41130);
        }
    }

    function initialize(address _swapFactory) public {
        require(_initialized == false, "StakePoolController: initialized");
        governance = msg.sender;
        swapFactory = IValueLiquidFactory(_swapFactory);
        _initialized = true;
    }

    function isStakePool(address b) external view override returns (bool) {
        return _stakePools[b];
    }

    modifier onlyGovernance() {
        require(msg.sender == governance, "StakePoolController: !governance");
        _;
    }

    function setFeeCollector(address _address) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        feeCollector = _address;
        emit SetFeeCollector(_address);
    }

    function setEnableWhitelistRewardRebaser(bool value) external override onlyGovernance {
        enableWhitelistRewardRebaser = value;
    }

    function setEnableWhitelistRewardMultiplier(bool value) external override onlyGovernance {
        enableWhitelistRewardMultiplier = value;
    }

    function setFeeToken(address _token) external override onlyGovernance {
        require(_token != address(0), "StakePoolController: invalid _token");
        feeToken = _token;
        emit SetFeeToken(_token);
    }

    function setFeeAmount(uint256 _feeAmount) external override onlyGovernance {
        feeAmount = _feeAmount;
        emit SetFeeAmount(_feeAmount);
    }

    function isWhitelistStakingFor(address _address) external view override returns (bool) {
        return _whitelistStakingFor[_address];
    }

    function isWhitelistStakePool(address _address) external view override returns (int8) {
        return _whitelistStakePools[_address];
    }

    function isStakePoolVerifier(address _address) external view override returns (bool) {
        return _stakePoolVerifiers[_address];
    }

    function isAllowEmergencyWithdrawStakePool(address _address) external view override returns (bool) {
        return allowEmergencyWithdrawStakePools[_address];
    }

    function setWhitelistStakingFor(address _address, bool state) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        _whitelistStakingFor[_address] = state;
        emit SetWhitelistStakingFor(_address, state);
    }

    function setAllowEmergencyWithdrawStakePool(address _address, bool state) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        allowEmergencyWithdrawStakePools[_address] = state;
    }

    function setStakePoolVerifier(address _address, bool state) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        _stakePoolVerifiers[_address] = state;
        emit SetStakePoolVerifier(_address, state);
    }

    function setWhitelistStakePool(address _address, int8 state) external override {
        require(_address != address(0), "StakePoolController: invalid address");
        require(_stakePoolVerifiers[msg.sender] == true, "StakePoolController: invalid stake pool verifier");
        _whitelistStakePools[_address] = state;
        emit SetWhitelistStakePool(_address, state);
    }

    function addStakePoolCreator(address _address) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        uint256 version = IStakePoolCreator(_address).version();
        require(version >= 1000, "Invalid stake pool creator version");
        stakePoolCreators[version] = _address;
        emit SetStakePoolCreator(_address, version);
    }

    function isWhitelistRewardRebaser(address _address) external view override returns (bool) {
        if (!enableWhitelistRewardRebaser) return true;
        return _address == address(0) ? true : _whitelistRewardRebaser[_address];
    }

    function setWhitelistRewardRebaser(address _address, bool state) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        _whitelistRewardRebaser[_address] = state;
        emit SetWhitelistRewardRebaser(_address, state);
    }

    function isWhitelistRewardMultiplier(address _address) external view override returns (bool) {
        if (!enableWhitelistRewardMultiplier) return true;
        return _address == address(0) ? true : _whitelistRewardMultiplier[_address];
    }

    function setWhitelistRewardMultiplier(address _address, bool state) external override onlyGovernance {
        require(_address != address(0), "StakePoolController: invalid address");
        _whitelistRewardMultiplier[_address] = state;
        emit SetWhitelistRewardMultiplier(_address, state);
    }

    function setGovernance(address _governance) external override onlyGovernance {
        require(_governance != address(0), "StakePoolController: invalid governance");
        governance = _governance;
        emit ChangeGovernance(_governance);
    }

    function allStakePoolsLength() external view override returns (uint256) {
        return allStakePools.length;
    }

    function createPair(
        uint256 version,
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata poolRewardInfo,
        uint8 flag
    ) public override discountCHI(flag) returns (address) {
        address pair = swapFactory.getPair(tokenA, tokenB, tokenWeightA, swapFee);
        if (pair == address(0)) {
            pair = swapFactory.createPair(tokenA, tokenB, tokenWeightA, swapFee);
        }
        return create(version, pair, rewardToken, rewardFundAmount, delayTimeLock, poolRewardInfo, 0);
    }

    function createInternal(
        address stakePoolCreator,
        address pair,
        address stakePoolRewardFund,
        address rewardToken,
        uint256 delayTimeLock,
        bytes calldata data
    ) internal returns (address) {
        TimeLock timelock = new TimeLock();
        IStakePool pool = IStakePool(IStakePoolCreator(stakePoolCreator).create());
        allStakePools.push(address(pool));
        _stakePools[address(pool)] = true;
        emit MasterCreated(address(pool), pair, pool.version(), address(timelock), stakePoolRewardFund, allStakePools.length);
        IStakePoolCreator(stakePoolCreator).initialize(address(pool), pair, rewardToken, address(timelock), address(stakePoolRewardFund), data);
        StakePoolRewardFund(stakePoolRewardFund).initialize(address(pool), address(timelock));
        timelock.initialize(msg.sender, delayTimeLock);
        return address(pool);
    }

    function create(
        uint256 version,
        address pair,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata data,
        uint8 flag
    ) public override discountCHI(flag) returns (address) {
        require(swapFactory.isPair(pair), "StakePoolController: invalid pair");
        address stakePoolCreator = stakePoolCreators[version];
        require(stakePoolCreator != address(0), "StakePoolController: Invalid stake pool creator version");

        if (feeCollector != address(0) && feeToken != address(0) && feeAmount > 0) {
            TransferHelper.safeTransferFrom(feeToken, msg.sender, feeCollector, feeAmount);
        }

        StakePoolRewardFund stakePoolRewardFund = new StakePoolRewardFund();
        if (rewardFundAmount > 0) {
            require(IERC20(rewardToken).balanceOf(msg.sender) >= rewardFundAmount, "StakePoolController: Not enough rewardFundAmount");
            TransferHelper.safeTransferFrom(rewardToken, msg.sender, address(stakePoolRewardFund), rewardFundAmount);
        }
        return createInternal(stakePoolCreator, pair, address(stakePoolRewardFund), rewardToken, delayTimeLock, data);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"txHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"string","name":"signature","type":"string"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"eta","type":"uint256"}],"name":"CancelTransaction","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"txHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"string","name":"signature","type":"string"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"eta","type":"uint256"}],"name":"ExecuteTransaction","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"NewAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newDelay","type":"uint256"}],"name":"NewDelay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPendingAdmin","type":"address"}],"name":"NewPendingAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"txHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"string","name":"signature","type":"string"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"eta","type":"uint256"}],"name":"QueueTransaction","type":"event"},{"inputs":[],"name":"GRACE_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"admin_initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"signature","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"eta","type":"uint256"}],"name":"cancelTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"signature","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"eta","type":"uint256"}],"name":"executeTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"uint256","name":"_delay","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"signature","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"eta","type":"uint256"}],"name":"queueTransaction","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"queuedTransactions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_delay","type":"uint256"}],"name":"setDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingAdmin","type":"address"}],"name":"setPendingAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Deployed Bytecode

Decompile Bytecode

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

Deployed Bytecode Sourcemap

20246:5515:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24273:1375;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22306:240;;;;;;;;;;;;;:::i;:::-;;21088:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;23099:665::-;;;;;;;;;;-1:-1:-1;23099:665:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;22554:537::-;;;;;;;;;;-1:-1:-1;22554:537:0;;;;;:::i;:::-;;:::i;23772:493::-;;;;;;;;;;-1:-1:-1;23772:493:0;;;;;:::i;:::-;;:::i;21122:20::-;;;;;;;;;;;;;:::i;21149:29::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;20975:47::-;;;;;;;;;;;;;:::i;20922:46::-;;;;;;;;;;;;;:::i;20869:::-;;;;;;;;;;;;;:::i;21341:505::-;;;;;;;;;;-1:-1:-1;21341:505:0;;;;;:::i;:::-;;:::i;21891:407::-;;;;;;;;;;-1:-1:-1;21891:407:0;;;;;:::i;:::-;;:::i;21185:50::-;;;;;;;;;;-1:-1:-1;21185:50:0;;;;;:::i;:::-;;:::i;21061:20::-;;;;;;;;;;;;;:::i;24273:1375::-;24512:5;;24465:12;;24512:5;;;;;24498:10;:19;24490:88;;;;;;;;;;;;:::i;:::-;;;;;;;;;24591:14;24629:6;24637:5;24644:9;24655:4;24661:3;24618:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;24608:58;;24618:47;24608:58;;;;24685:26;;;;:18;:26;;;;;;24608:58;;-1:-1:-1;24685:26:0;;24677:100;;;;;;;;;;;;:::i;:::-;24819:3;24796:19;:17;:19::i;:::-;:26;;24788:108;;;;;;;;;;;;:::i;:::-;24938:21;:3;20908:7;24938;:21::i;:::-;24915:19;:17;:19::i;:::-;:44;;24907:108;;;;;;;;;;;;:::i;:::-;25057:5;25028:26;;;:18;:26;;;;;:34;;;;;;25113:23;;25075:21;;25109:179;;-1:-1:-1;25169:4:0;25109:179;;;25257:9;25241:27;;;;;;25271:4;25217:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;25206:70;;25109:179;25361:12;25375:23;25402:6;:11;;25421:5;25428:8;25402:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25360:77;;;;25456:7;25448:81;;;;;;;;;;;;:::i;:::-;25574:6;25547:63;;25566:6;25547:63;25582:5;25589:9;25600:4;25606:3;25547:63;;;;;;;;;:::i;:::-;;;;;;;;25630:10;24273:1375;-1:-1:-1;;;;;;;;;24273:1375:0:o;22306:240::-;22369:12;;;;22355:10;:26;22347:95;;;;;;;;;;;;:::i;:::-;22453:5;:18;;;22461:10;22453:18;;;;;;;;;;;;;:5;22482:25;;;;;;22523:15;;22532:5;;;22453:18;22532:5;;22523:15;;;22306:240::o;21088:27::-;;;;;;:::o;23099:665::-;23281:7;23323:5;;;;;;;23309:10;:19;23301:86;;;;;;;;;;;;:::i;:::-;23413:30;23437:5;;23413:19;:17;:19::i;:::-;:23;;:30::i;:::-;23406:3;:37;;23398:123;;;;;;;;;;;;:::i;:::-;23534:14;23572:6;23580:5;23587:9;23598:4;23604:3;23561:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;23551:58;;23561:47;23551:58;;;;23620:26;;;;:18;:26;;;;;;:33;;;;23649:4;23620:33;;;23551:58;-1:-1:-1;23671:61:0;;;;23551:58;;23671:61;;;;23704:5;;23711:9;;23722:4;;23728:3;;23671:61;:::i;:::-;;;;;;;;23750:6;23099:665;-1:-1:-1;;;;;;23099:665:0:o;22554:537::-;22693:17;;;;22689:309;;;22735:10;22757:4;22735:27;22727:96;;;;;;;;;;;;:::i;:::-;22689:309;;;22878:5;;;;;;;22864:10;:19;22856:91;;;;;;;;;;;;:::i;:::-;22962:17;:24;;;;22982:4;22962:24;;;22689:309;23008:12;:28;;;;;;;;;;;;;;;;23054:29;;23070:12;;;23054:29;;-1:-1:-1;;23054:29:0;22554:537;:::o;23772:493::-;23979:5;;;;;;;23965:10;:19;23957:87;;;;;;;;;;;;:::i;:::-;24057:14;24095:6;24103:5;24110:9;24121:4;24127:3;24084:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;24074:58;;24084:47;24074:58;;;;24172:5;24143:26;;;:18;:26;;;;;;:34;;;;;;24074:58;-1:-1:-1;24195:62:0;;;;24074:58;;24195:62;;;;24229:5;;24236:9;;24247:4;;24253:3;;24195:62;:::i;:::-;;;;;;;;23772:493;;;;;;:::o;21122:20::-;;;;:::o;21149:29::-;;;;;;:::o;20975:47::-;21015:7;20975:47;:::o;20922:46::-;20962:6;20922:46;:::o;20869:::-;20908:7;20869:46;:::o;21341:505::-;21419:12;;;;:21;21411:83;;;;;;;;;;;;:::i;:::-;20962:6;21513;:23;;21505:88;;;;;;;;;;;;:::i;:::-;21015:7;21612:6;:23;;21604:92;;;;;;;;;;;;:::i;:::-;21707:5;:14;;;21732:5;:14;;:5;:14;;;;;;;;;;;;;;;21757:19;;;;;;;;;21792:15;;21801:5;;;;;21792:15;;;21832:5;;21823:15;;;;;;;21341:505;;:::o;21891:407::-;21951:10;21973:4;21951:27;21943:89;;;;;;;;;;;;:::i;:::-;20962:6;22051;:23;;22043:88;;;;;;;;;;;;:::i;:::-;21015:7;22150:6;:23;;22142:92;;;;;;;;;;;;:::i;:::-;22245:5;:14;;;22275:15;;22253:6;;22275:15;;;;;21891:407;:::o;21185:50::-;;;;;;;;;;;;;;;:::o;21061:20::-;;;;;;;;;:::o;25656:102::-;25735:15;25656:102;:::o;19639:137::-;19732:5;;;19727:16;;;;19719:49;;;;;;;;;;;;:::i;:::-;19639:137;;;;:::o;14:648:1:-;;110:18;151:2;143:6;140:14;137:2;;;157:9;137:2;197;191:9;336:4;266:66;259:4;251:6;247:17;243:90;235:6;231:103;227:114;391:6;379:10;376:22;371:2;359:10;356:18;353:46;350:2;;;402:9;350:2;429;422:22;477;;;462:6;-1:-1:-1;462:6:1;514:16;;;511:25;-1:-1:-1;508:2:1;;;549:1;546;539:12;508:2;599:6;594:3;587:4;579:6;575:17;562:44;654:1;647:4;638:6;630;626:19;622:30;615:41;;;90:572;;;;;:::o;667:198::-;737:20;;797:42;786:54;;776:65;;766:2;;855:1;852;845:12;766:2;718:147;;;:::o;870:198::-;;982:2;970:9;961:7;957:23;953:32;950:2;;;1003:6;995;988:22;950:2;1031:31;1052:9;1031:31;:::i;:::-;1021:41;940:128;-1:-1:-1;;;940:128:1:o;1073:266::-;;;1202:2;1190:9;1181:7;1177:23;1173:32;1170:2;;;1223:6;1215;1208:22;1170:2;1251:31;1272:9;1251:31;:::i;:::-;1241:41;1329:2;1314:18;;;;1301:32;;-1:-1:-1;;;1160:179:1:o;1344:1066::-;;;;;;1543:3;1531:9;1522:7;1518:23;1514:33;1511:2;;;1565:6;1557;1550:22;1511:2;1593:31;1614:9;1593:31;:::i;:::-;1583:41;;1671:2;1660:9;1656:18;1643:32;1633:42;;1726:2;1715:9;1711:18;1698:32;1749:18;1790:2;1782:6;1779:14;1776:2;;;1811:6;1803;1796:22;1776:2;1854:6;1843:9;1839:22;1829:32;;1899:7;1892:4;1888:2;1884:13;1880:27;1870:2;;1926:6;1918;1911:22;1870:2;1954:75;2021:7;2016:2;2003:16;1998:2;1994;1990:11;1954:75;:::i;:::-;1944:85;;2082:2;2071:9;2067:18;2054:32;2038:48;;2111:2;2101:8;2098:16;2095:2;;;2132:6;2124;2117:22;2095:2;-1:-1:-1;2160:24:1;;2215:4;2207:13;;2203:27;-1:-1:-1;2193:2:1;;2249:6;2241;2234:22;2193:2;2277:75;2344:7;2339:2;2326:16;2321:2;2317;2313:11;2277:75;:::i;:::-;1501:909;;;;-1:-1:-1;1501:909:1;;2399:3;2384:19;2371:33;;1501:909;-1:-1:-1;;;1501:909:1:o;2415:190::-;;2527:2;2515:9;2506:7;2502:23;2498:32;2495:2;;;2548:6;2540;2533:22;2495:2;-1:-1:-1;2576:23:1;;2485:120;-1:-1:-1;2485:120:1:o;2805:318::-;;2886:5;2880:12;2913:6;2908:3;2901:19;2929:63;2985:6;2978:4;2973:3;2969:14;2962:4;2955:5;2951:16;2929:63;:::i;:::-;3037:2;3025:15;3042:66;3021:88;3012:98;;;;3112:4;3008:109;;2856:267;-1:-1:-1;;2856:267:1:o;3128:417::-;;3325:66;3317:6;3313:79;3308:3;3301:92;3422:6;3416:13;3438:61;3492:6;3488:1;3483:3;3479:11;3472:4;3464:6;3460:17;3438:61;:::i;:::-;3519:16;;;;3537:1;3515:24;;3291:254;-1:-1:-1;;;3291:254:1:o;3550:274::-;;3717:6;3711:13;3733:53;3779:6;3774:3;3767:4;3759:6;3755:17;3733:53;:::i;:::-;3802:16;;;;;3687:137;-1:-1:-1;;3687:137:1:o;3829:226::-;4005:42;3993:55;;;;3975:74;;3963:2;3948:18;;3930:125::o;4060:648::-;;4351:42;4343:6;4339:55;4328:9;4321:74;4431:6;4426:2;4415:9;4411:18;4404:34;4474:3;4469:2;4458:9;4454:18;4447:31;4501:47;4543:3;4532:9;4528:19;4520:6;4501:47;:::i;:::-;4596:9;4588:6;4584:22;4579:2;4568:9;4564:18;4557:50;4624:34;4651:6;4643;4624:34;:::i;:::-;4616:42;;;4695:6;4689:3;4678:9;4674:19;4667:35;4311:397;;;;;;;;:::o;4713:187::-;4878:14;;4871:22;4853:41;;4841:2;4826:18;;4808:92::o;4905:177::-;5051:25;;;5039:2;5024:18;;5006:76::o;5087:219::-;;5234:2;5223:9;5216:21;5254:46;5296:2;5285:9;5281:18;5273:6;5254:46;:::i;5311:420::-;5513:2;5495:21;;;5552:2;5532:18;;;5525:30;5591:34;5586:2;5571:18;;5564:62;5662:26;5657:2;5642:18;;5635:54;5721:3;5706:19;;5485:246::o;5736:419::-;5938:2;5920:21;;;5977:2;5957:18;;;5950:30;6016:34;6011:2;5996:18;;5989:62;6087:25;6082:2;6067:18;;6060:53;6145:3;6130:19;;5910:245::o;6160:413::-;6362:2;6344:21;;;6401:2;6381:18;;;6374:30;6440:34;6435:2;6420:18;;6413:62;6511:19;6506:2;6491:18;;6484:47;6563:3;6548:19;;6334:239::o;6578:415::-;6780:2;6762:21;;;6819:2;6799:18;;;6792:30;6858:34;6853:2;6838:18;;6831:62;6929:21;6924:2;6909:18;;6902:49;6983:3;6968:19;;6752:241::o;6998:473::-;7200:2;7182:21;;;7239:2;7219:18;;;7212:30;7278:34;7273:2;7258:18;;7251:62;7349:34;7344:2;7329:18;;7322:62;7421:7;7415:3;7400:19;;7393:36;7461:3;7446:19;;7172:299::o;7476:344::-;7678:2;7660:21;;;7717:2;7697:18;;;7690:30;7756:22;7751:2;7736:18;;7729:50;7811:2;7796:18;;7650:170::o;7825:416::-;8027:2;8009:21;;;8066:2;8046:18;;;8039:30;8105:34;8100:2;8085:18;;8078:62;8176:22;8171:2;8156:18;;8149:50;8231:3;8216:19;;7999:242::o;8246:423::-;8448:2;8430:21;;;8487:2;8467:18;;;8460:30;8526:34;8521:2;8506:18;;8499:62;8597:29;8592:2;8577:18;;8570:57;8659:3;8644:19;;8420:249::o;8674:420::-;8876:2;8858:21;;;8915:2;8895:18;;;8888:30;8954:34;8949:2;8934:18;;8927:62;9025:26;9020:2;9005:18;;8998:54;9084:3;9069:19;;8848:246::o;9099:425::-;9301:2;9283:21;;;9340:2;9320:18;;;9313:30;9379:34;9374:2;9359:18;;9352:62;9450:31;9445:2;9430:18;;9423:59;9514:3;9499:19;;9273:251::o;9529:420::-;9731:2;9713:21;;;9770:2;9750:18;;;9743:30;9809:34;9804:2;9789:18;;9782:62;9880:26;9875:2;9860:18;;9853:54;9939:3;9924:19;;9703:246::o;9954:420::-;10156:2;10138:21;;;10195:2;10175:18;;;10168:30;10234:34;10229:2;10214:18;;10207:62;10305:26;10300:2;10285:18;;10278:54;10364:3;10349:19;;10128:246::o;10379:418::-;10581:2;10563:21;;;10620:2;10600:18;;;10593:30;10659:34;10654:2;10639:18;;10632:62;10730:24;10725:2;10710:18;;10703:52;10787:3;10772:19;;10553:244::o;10802:425::-;11004:2;10986:21;;;11043:2;11023:18;;;11016:30;11082:34;11077:2;11062:18;;11055:62;11153:31;11148:2;11133:18;;11126:59;11217:3;11202:19;;10976:251::o;11232:477::-;11434:2;11416:21;;;11473:2;11453:18;;;11446:30;11512:34;11507:2;11492:18;;11485:62;11583:34;11578:2;11563:18;;11556:62;11655:11;11649:3;11634:19;;11627:40;11699:3;11684:19;;11406:303::o;11714:413::-;11916:2;11898:21;;;11955:2;11935:18;;;11928:30;11994:34;11989:2;11974:18;;11967:62;12065:19;12060:2;12045:18;;12038:47;12117:3;12102:19;;11888:239::o;12314:527::-;;12565:6;12554:9;12547:25;12608:3;12603:2;12592:9;12588:18;12581:31;12635:47;12677:3;12666:9;12662:19;12654:6;12635:47;:::i;:::-;12730:9;12722:6;12718:22;12713:2;12702:9;12698:18;12691:50;12758:34;12785:6;12777;12758:34;:::i;:::-;12750:42;;;12828:6;12823:2;12812:9;12808:18;12801:34;12537:304;;;;;;;:::o;12846:258::-;12918:1;12928:113;12942:6;12939:1;12936:13;12928:113;;;13018:11;;;13012:18;12999:11;;;12992:39;12964:2;12957:10;12928:113;;;13059:6;13056:1;13053:13;13050:2;;;13094:1;13085:6;13080:3;13076:16;13069:27;13050:2;;12899:205;;;:::o

Swarm Source

ipfs://b8f6fc822616625a0ee54967bb439f69297337cac5461d27d4c32aa0173d93d2

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 30 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

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.

Tools & Services