Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(
• functionStaticCall(
•    - function functionStaticCall(
•    - function functionDelegateCall(
• functionDelegateCall(
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•  contract XEDStaking *
•    - function earlyStake(address _userAddr ...
•    - function stake(uint256 xedAmount)
•    - function unstake()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2025-01-21
*/

// SPDX-License-Identifier: MIT
// Sources flattened with hardhat v2.9.9 https://hardhat.org

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

// 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);
}

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

// 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);
}

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

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data
    ) internal view returns (bytes memory) {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

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

// File contracts/XEDStaking.sol

pragma solidity ^0.8.14;

enum EventType {
    Stake,
    Unstake,
    EarlyStake
}

contract XEDStaking {
    using SafeERC20 for IERC20;

    IERC20 private immutable xedToken;
    address public immutable migrationContract;

    struct UserInfo {
        uint256 stakingStart;
        uint256 stakedAmount;
        bool isEarlyStaker;
    }

    mapping(address => UserInfo) public userInfo;

    event EarlyStake(address indexed userAddress, uint256 amount);
    event Stake(address indexed userAddress, uint256 amount);
    event Unstake(address indexed userAddress, uint256 amount);

    constructor(IERC20 _xedToken, address _migrationContract) {
        xedToken = _xedToken;
        migrationContract = _migrationContract;
    }

    function earlyStake(address _userAddress, uint256 _xedAmount) external {
        require(
            msg.sender == migrationContract,
            "Only migration contract can call this"
        );

        UserInfo storage user = userInfo[_userAddress];
        require(user.stakingStart == 0, "User is already staking");

        user.stakingStart = block.timestamp;
        user.stakedAmount = _xedAmount;
        user.isEarlyStaker = true;

        xedToken.safeTransferFrom(msg.sender, address(this), _xedAmount);

        emit EarlyStake(_userAddress, _xedAmount);
    }

    function stake(uint256 xedAmount) external {
        UserInfo storage user = userInfo[msg.sender];
        require(user.stakingStart == 0, "User is already staking");

        user.stakingStart = block.timestamp;
        user.stakedAmount = xedAmount;
        user.isEarlyStaker = false;

        xedToken.safeTransferFrom(msg.sender, address(this), xedAmount);

        emit Stake(msg.sender, xedAmount);
    }

    function unstake() external {
        UserInfo storage user = userInfo[msg.sender];

        uint256 stakedAmount = user.stakedAmount;
        require(stakedAmount > 0, "User is not staking");

        delete userInfo[msg.sender];

        xedToken.safeTransfer(msg.sender, stakedAmount);

        emit Unstake(msg.sender, stakedAmount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_xedToken","type":"address"},{"internalType":"address","name":"_migrationContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EarlyStake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstake","type":"event"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_xedAmount","type":"uint256"}],"name":"earlyStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrationContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"xedAmount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"stakingStart","type":"uint256"},{"internalType":"uint256","name":"stakedAmount","type":"uint256"},{"internalType":"bool","name":"isEarlyStaker","type":"bool"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000ef7f7820a001aabac5e0979b175c9ff8af3dd4ec000000000000000000000000beafd8600ee870bb3d5bbe5d248dbbe3fa2b82f0

-----Decoded View---------------
Arg [0] : _xedToken (address): 0xef7f7820a001aabAc5E0979b175C9ff8Af3Dd4ec
Arg [1] : _migrationContract (address): 0xBeAfD8600ee870Bb3D5BbE5d248DBBE3FA2B82f0

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000ef7f7820a001aabac5e0979b175c9ff8af3dd4ec
Arg [1] : 000000000000000000000000beafd8600ee870bb3d5bbe5d248dbbe3fa2b82f0

19543:2068:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19645:42;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19819:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;21254:354;;;:::i;:::-;;20224:592;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20824:422;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19645:42;;;:::o;19819:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;21254:354::-;21293:21;21317:8;:20;21326:10;21317:20;;;;;;;;;;;;;;;21293:44;;21350:20;21373:4;:17;;;21350:40;;21424:1;21409:12;:16;21401:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;21469:8;:20;21478:10;21469:20;;;;;;;;;;;;;;;;21462:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21502:47;21524:10;21536:12;21502:8;:21;;;;:47;;;;;:::i;:::-;21575:10;21567:33;;;21587:12;21567:33;;;;;;:::i;:::-;;;;;;;;21282:326;;21254:354::o;20224:592::-;20342:17;20328:31;;:10;:31;;;20306:118;;;;;;;;;;;;:::i;:::-;;;;;;;;;20437:21;20461:8;:22;20470:12;20461:22;;;;;;;;;;;;;;;20437:46;;20523:1;20502:4;:17;;;:22;20494:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;20585:15;20565:4;:17;;:35;;;;20631:10;20611:4;:17;;:30;;;;20673:4;20652;:18;;;:25;;;;;;;;;;;;;;;;;;20690:64;20716:10;20736:4;20743:10;20690:8;:25;;;;:64;;;;;;:::i;:::-;20783:12;20772:36;;;20797:10;20772:36;;;;;;:::i;:::-;;;;;;;;20295:521;20224:592;;:::o;20824:422::-;20878:21;20902:8;:20;20911:10;20902:20;;;;;;;;;;;;;;;20878:44;;20962:1;20941:4;:17;;;:22;20933:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;21024:15;21004:4;:17;;:35;;;;21070:9;21050:4;:17;;:29;;;;21111:5;21090:4;:18;;;:26;;;;;;;;;;;;;;;;;;21129:63;21155:10;21175:4;21182:9;21129:8;:25;;;;:63;;;;;;:::i;:::-;21216:10;21210:28;;;21228:9;21210:28;;;;;;:::i;:::-;;;;;;;;20867:379;20824:422;:::o;15141:214::-;15224:123;15258:5;15301:23;;;15326:2;15330:5;15278:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15224:19;:123::i;:::-;15141:214;;;:::o;15363:285::-;15507:133;15541:5;15584:27;;;15613:4;15619:2;15623:5;15561:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15507:19;:133::i;:::-;15363:285;;;;:::o;18605:802::-;19029:23;19055:106;19097:4;19055:106;;;;;;;;;;;;;;;;;19063:5;19055:27;;;;:106;;;;;:::i;:::-;19029:132;;19196:1;19176:10;:17;:21;19172:228;;;19291:10;19280:30;;;;;;;;;;;;:::i;:::-;19254:134;;;;;;;;;;;;:::i;:::-;;;;;;;;;19172:228;18675:732;18605:802;;:::o;9489:229::-;9626:12;9658:52;9680:6;9688:4;9694:1;9697:12;9658:21;:52::i;:::-;9651:59;;9489:229;;;;;:::o;10705:571::-;10875:12;10947:5;10922:21;:30;;10900:118;;;;;;;;;;;;:::i;:::-;;;;;;;;;11037:18;11048:6;11037:10;:18::i;:::-;11029:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;11103:12;11117:23;11144:6;:11;;11163:5;11184:4;11144:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11102:97;;;;11217:51;11234:7;11243:10;11255:12;11217:16;:51::i;:::-;11210:58;;;;10705:571;;;;;;:::o;6645:326::-;6705:4;6962:1;6940:7;:19;;;:23;6933:30;;6645:326;;;:::o;13660:762::-;13810:12;13839:7;13835:580;;;13870:10;13863:17;;;;13835:580;14004:1;13984:10;:17;:21;13980:424;;;14232:10;14226:17;14293:15;14280:10;14276:2;14272:19;14265:44;13980:424;14375:12;14368:20;;;;;;;;;;;:::i;:::-;;;;;;;;13660:762;;;;;;:::o;7:126:1:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;674:117::-;783:1;780;773:12;920:122;993:24;1011:5;993:24;:::i;:::-;986:5;983:35;973:63;;1032:1;1029;1022:12;973:63;920:122;:::o;1048:139::-;1094:5;1132:6;1119:20;1110:29;;1148:33;1175:5;1148:33;:::i;:::-;1048:139;;;;:::o;1193:329::-;1252:6;1301:2;1289:9;1280:7;1276:23;1272:32;1269:119;;;1307:79;;:::i;:::-;1269:119;1427:1;1452:53;1497:7;1488:6;1477:9;1473:22;1452:53;:::i;:::-;1442:63;;1398:117;1193:329;;;;:::o;1528:77::-;1565:7;1594:5;1583:16;;1528:77;;;:::o;1611:118::-;1698:24;1716:5;1698:24;:::i;:::-;1693:3;1686:37;1611:118;;:::o;1735:90::-;1769:7;1812:5;1805:13;1798:21;1787:32;;1735:90;;;:::o;1831:109::-;1912:21;1927:5;1912:21;:::i;:::-;1907:3;1900:34;1831:109;;:::o;1946:430::-;2089:4;2127:2;2116:9;2112:18;2104:26;;2140:71;2208:1;2197:9;2193:17;2184:6;2140:71;:::i;:::-;2221:72;2289:2;2278:9;2274:18;2265:6;2221:72;:::i;:::-;2303:66;2365:2;2354:9;2350:18;2341:6;2303:66;:::i;:::-;1946:430;;;;;;:::o;2382:122::-;2455:24;2473:5;2455:24;:::i;:::-;2448:5;2445:35;2435:63;;2494:1;2491;2484:12;2435:63;2382:122;:::o;2510:139::-;2556:5;2594:6;2581:20;2572:29;;2610:33;2637:5;2610:33;:::i;:::-;2510:139;;;;:::o;2655:474::-;2723:6;2731;2780:2;2768:9;2759:7;2755:23;2751:32;2748:119;;;2786:79;;:::i;:::-;2748:119;2906:1;2931:53;2976:7;2967:6;2956:9;2952:22;2931:53;:::i;:::-;2921:63;;2877:117;3033:2;3059:53;3104:7;3095:6;3084:9;3080:22;3059:53;:::i;:::-;3049:63;;3004:118;2655:474;;;;;:::o;3135:329::-;3194:6;3243:2;3231:9;3222:7;3218:23;3214:32;3211:119;;;3249:79;;:::i;:::-;3211:119;3369:1;3394:53;3439:7;3430:6;3419:9;3415:22;3394:53;:::i;:::-;3384:63;;3340:117;3135:329;;;;:::o;3470:169::-;3554:11;3588:6;3583:3;3576:19;3628:4;3623:3;3619:14;3604:29;;3470:169;;;;:::o;3645:::-;3785:21;3781:1;3773:6;3769:14;3762:45;3645:169;:::o;3820:366::-;3962:3;3983:67;4047:2;4042:3;3983:67;:::i;:::-;3976:74;;4059:93;4148:3;4059:93;:::i;:::-;4177:2;4172:3;4168:12;4161:19;;3820:366;;;:::o;4192:419::-;4358:4;4396:2;4385:9;4381:18;4373:26;;4445:9;4439:4;4435:20;4431:1;4420:9;4416:17;4409:47;4473:131;4599:4;4473:131;:::i;:::-;4465:139;;4192:419;;;:::o;4617:222::-;4710:4;4748:2;4737:9;4733:18;4725:26;;4761:71;4829:1;4818:9;4814:17;4805:6;4761:71;:::i;:::-;4617:222;;;;:::o;4845:224::-;4985:34;4981:1;4973:6;4969:14;4962:58;5054:7;5049:2;5041:6;5037:15;5030:32;4845:224;:::o;5075:366::-;5217:3;5238:67;5302:2;5297:3;5238:67;:::i;:::-;5231:74;;5314:93;5403:3;5314:93;:::i;:::-;5432:2;5427:3;5423:12;5416:19;;5075:366;;;:::o;5447:419::-;5613:4;5651:2;5640:9;5636:18;5628:26;;5700:9;5694:4;5690:20;5686:1;5675:9;5671:17;5664:47;5728:131;5854:4;5728:131;:::i;:::-;5720:139;;5447:419;;;:::o;5872:173::-;6012:25;6008:1;6000:6;5996:14;5989:49;5872:173;:::o;6051:366::-;6193:3;6214:67;6278:2;6273:3;6214:67;:::i;:::-;6207:74;;6290:93;6379:3;6290:93;:::i;:::-;6408:2;6403:3;6399:12;6392:19;;6051:366;;;:::o;6423:419::-;6589:4;6627:2;6616:9;6612:18;6604:26;;6676:9;6670:4;6666:20;6662:1;6651:9;6647:17;6640:47;6704:131;6830:4;6704:131;:::i;:::-;6696:139;;6423:419;;;:::o;6848:332::-;6969:4;7007:2;6996:9;6992:18;6984:26;;7020:71;7088:1;7077:9;7073:17;7064:6;7020:71;:::i;:::-;7101:72;7169:2;7158:9;7154:18;7145:6;7101:72;:::i;:::-;6848:332;;;;;:::o;7186:442::-;7335:4;7373:2;7362:9;7358:18;7350:26;;7386:71;7454:1;7443:9;7439:17;7430:6;7386:71;:::i;:::-;7467:72;7535:2;7524:9;7520:18;7511:6;7467:72;:::i;:::-;7549;7617:2;7606:9;7602:18;7593:6;7549:72;:::i;:::-;7186:442;;;;;;:::o;7634:116::-;7704:21;7719:5;7704:21;:::i;:::-;7697:5;7694:32;7684:60;;7740:1;7737;7730:12;7684:60;7634:116;:::o;7756:137::-;7810:5;7841:6;7835:13;7826:22;;7857:30;7881:5;7857:30;:::i;:::-;7756:137;;;;:::o;7899:345::-;7966:6;8015:2;8003:9;7994:7;7990:23;7986:32;7983:119;;;8021:79;;:::i;:::-;7983:119;8141:1;8166:61;8219:7;8210:6;8199:9;8195:22;8166:61;:::i;:::-;8156:71;;8112:125;7899:345;;;;:::o;8250:229::-;8390:34;8386:1;8378:6;8374:14;8367:58;8459:12;8454:2;8446:6;8442:15;8435:37;8250:229;:::o;8485:366::-;8627:3;8648:67;8712:2;8707:3;8648:67;:::i;:::-;8641:74;;8724:93;8813:3;8724:93;:::i;:::-;8842:2;8837:3;8833:12;8826:19;;8485:366;;;:::o;8857:419::-;9023:4;9061:2;9050:9;9046:18;9038:26;;9110:9;9104:4;9100:20;9096:1;9085:9;9081:17;9074:47;9138:131;9264:4;9138:131;:::i;:::-;9130:139;;8857:419;;;:::o;9282:225::-;9422:34;9418:1;9410:6;9406:14;9399:58;9491:8;9486:2;9478:6;9474:15;9467:33;9282:225;:::o;9513:366::-;9655:3;9676:67;9740:2;9735:3;9676:67;:::i;:::-;9669:74;;9752:93;9841:3;9752:93;:::i;:::-;9870:2;9865:3;9861:12;9854:19;;9513:366;;;:::o;9885:419::-;10051:4;10089:2;10078:9;10074:18;10066:26;;10138:9;10132:4;10128:20;10124:1;10113:9;10109:17;10102:47;10166:131;10292:4;10166:131;:::i;:::-;10158:139;;9885:419;;;:::o;10310:179::-;10450:31;10446:1;10438:6;10434:14;10427:55;10310:179;:::o;10495:366::-;10637:3;10658:67;10722:2;10717:3;10658:67;:::i;:::-;10651:74;;10734:93;10823:3;10734:93;:::i;:::-;10852:2;10847:3;10843:12;10836:19;;10495:366;;;:::o;10867:419::-;11033:4;11071:2;11060:9;11056:18;11048:26;;11120:9;11114:4;11110:20;11106:1;11095:9;11091:17;11084:47;11148:131;11274:4;11148:131;:::i;:::-;11140:139;;10867:419;;;:::o;11292:98::-;11343:6;11377:5;11371:12;11361:22;;11292:98;;;:::o;11396:147::-;11497:11;11534:3;11519:18;;11396:147;;;;:::o;11549:246::-;11630:1;11640:113;11654:6;11651:1;11648:13;11640:113;;;11739:1;11734:3;11730:11;11724:18;11720:1;11715:3;11711:11;11704:39;11676:2;11673:1;11669:10;11664:15;;11640:113;;;11787:1;11778:6;11773:3;11769:16;11762:27;11611:184;11549:246;;;:::o;11801:386::-;11905:3;11933:38;11965:5;11933:38;:::i;:::-;11987:88;12068:6;12063:3;11987:88;:::i;:::-;11980:95;;12084:65;12142:6;12137:3;12130:4;12123:5;12119:16;12084:65;:::i;:::-;12174:6;12169:3;12165:16;12158:23;;11909:278;11801:386;;;;:::o;12193:271::-;12323:3;12345:93;12434:3;12425:6;12345:93;:::i;:::-;12338:100;;12455:3;12448:10;;12193:271;;;;:::o;12470:99::-;12522:6;12556:5;12550:12;12540:22;;12470:99;;;:::o;12575:102::-;12616:6;12667:2;12663:7;12658:2;12651:5;12647:14;12643:28;12633:38;;12575:102;;;:::o;12683:377::-;12771:3;12799:39;12832:5;12799:39;:::i;:::-;12854:71;12918:6;12913:3;12854:71;:::i;:::-;12847:78;;12934:65;12992:6;12987:3;12980:4;12973:5;12969:16;12934:65;:::i;:::-;13024:29;13046:6;13024:29;:::i;:::-;13019:3;13015:39;13008:46;;12775:285;12683:377;;;;:::o;13066:313::-;13179:4;13217:2;13206:9;13202:18;13194:26;;13266:9;13260:4;13256:20;13252:1;13241:9;13237:17;13230:47;13294:78;13367:4;13358:6;13294:78;:::i;:::-;13286:86;;13066:313;;;;:::o

ipfs://34d751c06227f5d776701e68ef411afaddf0c93903d18c76fd75263bde4b9e17