Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2024-10-09
*/

// Sources flattened with hardhat v2.22.6 https://hardhat.org

// SPDX-License-Identifier: GPL-3.0 AND MIT

// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}


// File @openzeppelin/contracts/access/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}


// File contracts/interfaces/IveCarv.sol

// Original license: SPDX_License_Identifier: GPL-3.0
pragma solidity 0.8.20;

interface IveCarv {

    /**
     * @notice This struct represents information about a Withdraw by the user.
     *
     * `withdrawer`: address of who initiates this Withdraw.
     * `canceledOrClaimed`: Has this Withdraw been canceled or claimed?
     * `amount`: The amount of Withdraw initiated by the user.
     * `timestamp`: The time this Withdraw was initiated.
     */
    struct WithdrawInfo {
        address withdrawer;
        bool canceledOrClaimed;
        uint256 amount;
        uint256 claimAmount;
        uint256 endAt;
    }

    event Deposit(address depositor, address receiver, uint256 amount);

    event Withdraw(uint64 indexed id, address withdrawer, uint256 amount, uint256 duration);

    event CancelWithdraw(uint64 indexed id);

    event Claim(uint64 id, uint256 amount);

    /**
     * @notice convert CARV to veCARV by locking CARV in this contract and minting veCARV to msg.sender.
     * @notice CARV can be converted to veCARV with 1:1 ratio through deposit.
     * @notice veCARV stands for voting-escrow CARV, is a non-transferable token. veCARV is mainly used for:
     * @notice 1. CARV Protocol governance.
     * @notice 2. Incentive to bootstrap incentive layer, e.g., data owners, providers, consumers.
     * @notice 3. Used for governance voting in P2E system 'Infinite Play'.
     * @notice 4. Used in P2E systems to delegate voting rights to escrow pool owners and receive pool rewards.
     * @notice 5. Incentivizes node operators who secure and support the network.
     *
     * @dev Emits `Deposit`.
     *
     * @param amount: amount of CARV to be deposited
     * @param receiver: receiver of veCARV Token
     */
    function deposit(uint256 amount, address receiver) external;

    /**
     * @notice convert veCARV to CARV, veCARV conversion to CARV requires an unlocking period.
     * @notice The withdraw rate varies for different unlocking periods,
     * @notice with longer unlocking periods resulting in higher withdraw rates, reaching up to 100%.
     * @notice Users are required to pay a network channel fee of 1 CARV each time they initiate a Withdraw.
     *
     * @dev Emits `Withdraw`.
     *
     * @param amount: amount of veCARV to be withdrawn
     */
    function withdraw(uint256 amount, uint256 duration) external;

    /**
     * @notice Cancel the Withdraw by withdrawID.
     * @notice It can be canceled before the user claims.
     * @notice After the operation, the locking veCARV is returned to msg.sender.
     *
     * @dev Emits `CancelWithdraw`.
     *
     * @param withdrawID: The withdrawID that the user needs to cancel
     */
    function cancelWithdraw(uint64 withdrawID) external;

    /**
     * @notice Return the CARV corresponding to the specified withdrawID to the user.
     * @notice The relationship between the user’s Locking Duration and claimable ratio is as follows:
     *    ----------------------------------------------------
     *    |   Locking Duration (Days)   |    Claims (CARV)   |
     *    |            15               |        25%         |
     *    |            90               |        60%         |
     *    |           150               |       100%         |
     *    ----------------------------------------------------
     * @notice after that, Burn the locking veCARV corresponding to the specified withdrawID
     * @notice If the Locking Duration is less than 150 days, the remaining CARV will be:
     * @notice 1. 50% enter the CARV foundation to maintain network operation.
     * @notice 2. 50% will be burned, which makes CARV deflationary.
     *
     * @dev Emits `Claim`.
     *
     * @param withdrawID: The withdrawID that the user needs to claim CARV
     */
    function claim(uint64 withdrawID) external;
}


// File contracts/airdrop/Airdrop02.sol

// Original license: SPDX_License_Identifier: GPL-3.0
pragma solidity 0.8.20;




contract Airdrop02 is Ownable {
    bytes32 public merkleRoot;
    address public immutable token;
    address public immutable veToken;
    mapping(address => bool) public claimed;

    event Claimed(address user, uint256 amount);
    event Deposit(address depositer, uint256 amount);
    event Withdraw(address withdrawer, uint256 amount);

    constructor(bytes32 merkleRoot_, address token_, address veToken_) Ownable(msg.sender) {
        require(token_ != address(0) && veToken_ != address(0));
        merkleRoot = merkleRoot_;
        token = token_;
        veToken = veToken_;
        IERC20(token).approve(veToken, type(uint256).max);
    }

    // deposit CARV token as airdrop reward
    function depositToken(uint256 amount) external {
        require(amount > 0, "invalid amount");
        IERC20(token).transferFrom(msg.sender, address(this), amount);
        emit Deposit(msg.sender, amount);
    }

    // withdraw CARV token in this contract (only owner can do this)
    function withdrawToken(uint256 amount) external onlyOwner {
        require(amount > 0, "invalid amount");
        IERC20(token).transfer(msg.sender, amount);
        emit Withdraw(msg.sender, amount);
    }

    function changeMerkleRoot(bytes32 merkleRoot_) external onlyOwner {
        merkleRoot = merkleRoot_;
    }

    function claim(uint256 amount, bytes32[] calldata merkleProof) external {
        require(!claimed[msg.sender], 'Drop already claimed');

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(msg.sender, amount));
        require(MerkleProof.verify(merkleProof, merkleRoot, node), 'Invalid proof');

        claimed[msg.sender] = true;
        // deposit CARV token to veCarv contract which will mint veCarv to user in 1:1
        IveCarv(veToken).deposit(amount, msg.sender);
        emit Claimed(msg.sender, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"},{"internalType":"address","name":"token_","type":"address"},{"internalType":"address","name":"veToken_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"depositer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"withdrawer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"name":"changeMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"veToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c08cd26474722ce93f4d0c34d16201461c10aa8c0000000000000000000000002b790dea1f6c5d72d5c60af0f9cd6834374a964b

-----Decoded View---------------
Arg [0] : merkleRoot_ (bytes32): 0x0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : token_ (address): 0xc08Cd26474722cE93F4D0c34D16201461c10AA8C
Arg [2] : veToken_ (address): 0x2b790Dea1f6c5d72D5C60aF0F9CD6834374a964B

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 000000000000000000000000c08cd26474722ce93f4d0c34d16201461c10aa8c
Arg [2] : 0000000000000000000000002b790dea1f6c5d72d5c60af0f9cd6834374a964b

21570:1922:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21607:25;;;;;;;;;160::1;;;148:2;133:18;21607:25:0;;;;;;;;22922:567;;;;;;:::i;:::-;;:::i;:::-;;21676:32;;;;;;;;-1:-1:-1;;;;;1048:32:1;;;1030:51;;1018:2;1003:18;21676:32:0;884:203:1;22586:211:0;;;;;;:::i;:::-;;:::i;22290:218::-;;;;;;:::i;:::-;;:::i;3583:103::-;;;:::i;2908:87::-;2954:7;2981:6;-1:-1:-1;;;;;2981:6:0;2908:87;;21715:39;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1733:14:1;;1726:22;1708:41;;1696:2;1681:18;21715:39:0;1568:187:1;22805:109:0;;;;;;:::i;:::-;;:::i;3841:220::-;;;;;;:::i;:::-;;:::i;21639:30::-;;;;;22922:567;23022:10;23014:19;;;;:7;:19;;;;;;;;23013:20;23005:53;;;;-1:-1:-1;;;23005:53:0;;2147:2:1;23005:53:0;;;2129:21:1;2186:2;2166:18;;;2159:30;-1:-1:-1;;;2205:18:1;;;2198:50;2265:18;;23005:53:0;;;;;;;;;23133:36;;-1:-1:-1;;23150:10:0;2471:2:1;2467:15;2463:53;23133:36:0;;;2451:66:1;2533:12;;;2526:28;;;23108:12:0;;2570::1;;23133:36:0;;;;;;;;;;;;23123:47;;;;;;23108:62;;23189:49;23208:11;;23189:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23221:10:0;;;-1:-1:-1;23233:4:0;;-1:-1:-1;23189:18:0;:49::i;:::-;23181:75;;;;-1:-1:-1;;;23181:75:0;;2795:2:1;23181:75:0;;;2777:21:1;2834:2;2814:18;;;2807:30;-1:-1:-1;;;2853:18:1;;;2846:43;2906:18;;23181:75:0;2593:337:1;23181:75:0;23277:10;23269:19;;;;:7;:19;;;;;;;:26;;-1:-1:-1;;23269:26:0;23291:4;23269:26;;;23394:44;-1:-1:-1;;;23394:44:0;;23402:7;-1:-1:-1;;;;;23394:24:0;;;;:44;;23419:6;;23394:44;;3109:25:1;;;-1:-1:-1;;;;;3170:32:1;3165:2;3150:18;;3143:60;3097:2;3082:18;;2935:274;23394:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23454:27:0;;;23462:10;3388:51:1;;3470:2;3455:18;;3448:34;;;23454:27:0;;-1:-1:-1;3361:18:1;;-1:-1:-1;23454:27:0;;;;;;;22994:495;22922:567;;;:::o;22586:211::-;2794:13;:11;:13::i;:::-;22672:1:::1;22663:6;:10;22655:37;;;::::0;-1:-1:-1;;;22655:37:0;;3695:2:1;22655:37:0::1;::::0;::::1;3677:21:1::0;3734:2;3714:18;;;3707:30;-1:-1:-1;;;3753:18:1;;;3746:44;3807:18;;22655:37:0::1;3493:338:1::0;22655:37:0::1;22703:42;::::0;-1:-1:-1;;;22703:42:0;;22726:10:::1;22703:42;::::0;::::1;3388:51:1::0;3455:18;;;3448:34;;;22710:5:0::1;-1:-1:-1::0;;;;;22703:22:0::1;::::0;::::1;::::0;3361:18:1;;22703:42:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;22761:28:0::1;::::0;;22770:10:::1;3388:51:1::0;;3470:2;3455:18;;3448:34;;;22761:28:0::1;::::0;3361:18:1;22761:28:0::1;;;;;;;;22586:211:::0;:::o;22290:218::-;22365:1;22356:6;:10;22348:37;;;;-1:-1:-1;;;22348:37:0;;3695:2:1;22348:37:0;;;3677:21:1;3734:2;3714:18;;;3707:30;-1:-1:-1;;;3753:18:1;;;3746:44;3807:18;;22348:37:0;3493:338:1;22348:37:0;22396:61;;-1:-1:-1;;;22396:61:0;;22423:10;22396:61;;;4358:34:1;22443:4:0;4408:18:1;;;4401:43;4460:18;;;4453:34;;;22403:5:0;-1:-1:-1;;;;;22396:26:0;;;;4293:18:1;;22396:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;22473:27:0;;;22481:10;3388:51:1;;3470:2;3455:18;;3448:34;;;22473:27:0;;3361:18:1;22473:27:0;3214:274:1;3583:103:0;2794:13;:11;:13::i;:::-;3648:30:::1;3675:1;3648:18;:30::i;:::-;3583:103::o:0;22805:109::-;2794:13;:11;:13::i;:::-;22882:10:::1;:24:::0;22805:109::o;3841:220::-;2794:13;:11;:13::i;:::-;-1:-1:-1;;;;;3926:22:0;::::1;3922:93;;3972:31;::::0;-1:-1:-1;;;3972:31:0;;4000:1:::1;3972:31;::::0;::::1;1030:51:1::0;1003:18;;3972:31:0::1;884:203:1::0;3922:93:0::1;4025:28;4044:8;4025:18;:28::i;:::-;3841:220:::0;:::o;8757:156::-;8848:4;8901;8872:25;8885:5;8892:4;8872:12;:25::i;:::-;:33;;8757:156;-1:-1:-1;;;;8757:156:0:o;3073:166::-;2954:7;2981:6;-1:-1:-1;;;;;2981:6:0;942:10;3133:23;3129:103;;3180:40;;-1:-1:-1;;;3180:40:0;;942:10;3180:40;;;1030:51:1;1003:18;;3180:40:0;884:203:1;4221:191:0;4295:16;4314:6;;-1:-1:-1;;;;;4331:17:0;;;-1:-1:-1;;;;;;4331:17:0;;;;;;4364:40;;4314:6;;;;;;;4364:40;;4295:16;4364:40;4284:128;4221:191;:::o;9476:296::-;9559:7;9602:4;9559:7;9617:118;9641:5;:12;9637:1;:16;9617:118;;;9690:33;9700:12;9714:5;9720:1;9714:8;;;;;;;;:::i;:::-;;;;;;;9690:9;:33::i;:::-;9675:48;-1:-1:-1;9655:3:0;;;;:::i;:::-;;;;9617:118;;;-1:-1:-1;9752:12:0;9476:296;-1:-1:-1;;;9476:296:0:o;16906:149::-;16969:7;17000:1;16996;:5;:51;;17248:13;17342:15;;;17378:4;17371:15;;;17425:4;17409:21;;16996:51;;;17248:13;17342:15;;;17378:4;17371:15;;;17425:4;17409:21;;17004:20;16989:58;16906:149;-1:-1:-1;;;16906:149:0:o;196:683:1:-;291:6;299;307;360:2;348:9;339:7;335:23;331:32;328:52;;;376:1;373;366:12;328:52;412:9;399:23;389:33;;473:2;462:9;458:18;445:32;496:18;537:2;529:6;526:14;523:34;;;553:1;550;543:12;523:34;591:6;580:9;576:22;566:32;;636:7;629:4;625:2;621:13;617:27;607:55;;658:1;655;648:12;607:55;698:2;685:16;724:2;716:6;713:14;710:34;;;740:1;737;730:12;710:34;793:7;788:2;778:6;775:1;771:14;767:2;763:23;759:32;756:45;753:65;;;814:1;811;804:12;753:65;845:2;841;837:11;827:21;;867:6;857:16;;;;;196:683;;;;;:::o;1092:180::-;1151:6;1204:2;1192:9;1183:7;1179:23;1175:32;1172:52;;;1220:1;1217;1210:12;1172:52;-1:-1:-1;1243:23:1;;1092:180;-1:-1:-1;1092:180:1:o;1277:286::-;1336:6;1389:2;1377:9;1368:7;1364:23;1360:32;1357:52;;;1405:1;1402;1395:12;1357:52;1431:23;;-1:-1:-1;;;;;1483:31:1;;1473:42;;1463:70;;1529:1;1526;1519:12;3836:277;3903:6;3956:2;3944:9;3935:7;3931:23;3927:32;3924:52;;;3972:1;3969;3962:12;3924:52;4004:9;3998:16;4057:5;4050:13;4043:21;4036:5;4033:32;4023:60;;4079:1;4076;4069:12;4498:127;4559:10;4554:3;4550:20;4547:1;4540:31;4590:4;4587:1;4580:15;4614:4;4611:1;4604:15;4630:232;4669:3;4690:17;;;4687:140;;4749:10;4744:3;4740:20;4737:1;4730:31;4784:4;4781:1;4774:15;4812:4;4809:1;4802:15;4687:140;-1:-1:-1;4854:1:1;4843:13;;4630:232::o

ipfs://c23967552875adefd95cd7329afa42d9a0cd2f6a39c0dda5964cd4c6ec51b287