Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "EIP712Verifier.sol";
import "IERC20.sol";
import "ECDSA.sol";
import "EIP712.sol";

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

interface IERC20Rebasing is IERC20 {
    function configure(YieldMode) external returns (uint256);

    function claim(
        address recipient,
        uint256 amount
    ) external returns (uint256);

    function getClaimableAmount(
        address account
    ) external view returns (uint256);
}

interface IBlast {
    function configureAutomaticYield() external;
    function configureClaimableGas() external;
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
}

interface IBlastPoints {
	function configurePointsOperator(address operator) external;
}

contract Bfx is EIP712Verifier {

    uint256 constant UNLOCKED = 1;
    uint256 constant LOCKED = 2;
    uint256 constant HUNDRED_DOLLARS = 1e19;
    uint256 constant MIN_DEPOSIT = 1e17;
    IBlast public constant BLAST = IBlast(0x4300000000000000000000000000000000000002);

    address public immutable owner;

    address public claimer;
    IERC20Rebasing public paymentToken;

    // record of already processed withdrawals
    mapping(uint256 => bool) public processedWithdrawals;

    uint256 nextDepositId = 74000;
    uint256 reentryLockStatus = UNLOCKED;

    event Deposit(uint256 indexed id, address indexed trader, uint256 amount);
    event WithdrawTo(address indexed to, uint256 amount);
    event WithdrawalReceipt(
        uint256 indexed id,
        address indexed trader,
        uint256 amount
    );
    event ClaimedYield(uint256 amount);
    event SetToken(address indexed token);
    event SetClaimer(address indexed claimer);
    event SetSigner(address indexed signer);

    modifier onlyOwner() {
        require(msg.sender == owner, "ONLY_OWNER");
        _;
    }

    modifier onlyClaimer() {
        require(msg.sender == claimer, "ONLY_CLAIMER");
        _;
    }

    modifier nonReentrant() {
        require(reentryLockStatus == UNLOCKED, "NO_REENTRY");
        reentryLockStatus = LOCKED;
        _;
        reentryLockStatus = UNLOCKED;
    }

    constructor(
        address _owner,
        address _signer,
        address _claimer,
        address _paymentToken,
        address _points
    ) EIP712Verifier("BfxWithdrawal", "1", _signer) {
        owner = _owner;
        claimer = _claimer;
        paymentToken = IERC20Rebasing(_paymentToken);
        paymentToken.configure(YieldMode.CLAIMABLE);
        BLAST.configureAutomaticYield();
        BLAST.configureClaimableGas();
        IBlastPoints(_points).configurePointsOperator(_claimer);
    }

    function claimYield() external nonReentrant onlyClaimer {
        uint256 claimable = paymentToken.getClaimableAmount(address(this));
        if (claimable > HUNDRED_DOLLARS) {
            uint256 balanceBefore = paymentToken.balanceOf(address(this));
            paymentToken.claim(address(this), claimable);
            uint256 balanceAfter = paymentToken.balanceOf(address(this));
            require(balanceAfter > balanceBefore, "CLAIM_DIDNT_INCREASE_BALANCE");
            emit ClaimedYield(balanceAfter - balanceBefore);
        }
    }

    function claimGas() external nonReentrant onlyClaimer {
        BLAST.claimMaxGas(address(this), claimer);
    }

    function withdraw(
        uint256 id,
        address trader,
        uint256 amount,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external nonReentrant {
        require(amount > 0, "WRONG_AMOUNT");
        require(processedWithdrawals[id] == false, "ALREADY_PROCESSED");
        processedWithdrawals[id] = true;
        bytes32 digest = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    keccak256(
                        "withdrawal(uint256 id,address trader,uint256 amount)"
                    ),
                    id,
                    trader,
                    amount
                )
            )
        );

        bool valid = verify(digest, v, r, s);
        require(valid, "INVALID_SIGNATURE");

        emit WithdrawalReceipt(id, trader, amount);
        bool success = makeTransfer(trader, amount);
        require(success, "TRANSFER_FAILED");
    }

    function setPaymentToken(address _paymentToken) external onlyOwner {
        paymentToken = IERC20Rebasing(_paymentToken);
        emit SetToken(_paymentToken);
    }

    function allocateDepositId() private returns (uint256 depositId) {
        depositId = nextDepositId;
        nextDepositId++;
        return depositId;
    }

    function deposit(uint256 amount) external nonReentrant {
        require(amount >= MIN_DEPOSIT, "WRONG_AMOUNT");
        bool success = makeTransferFrom(msg.sender, address(this) , amount);
        require(success, "TRANSFER_FAILED");
        uint256 depositId = allocateDepositId();
        emit Deposit(depositId, msg.sender, amount);
    }

    function withdrawTokensTo(uint256 amount, address to) external onlyOwner {
        require(amount > 0, "WRONG_AMOUNT");
        require(to != address(0), "ZERO_ADDRESS");
        bool success = makeTransfer(to, amount);
        require(success, "TRANSFER_FAILED");
        emit WithdrawTo(to, amount);
    }
    
    function changeSigner(address new_signer) external onlyOwner {
        require(new_signer != address(0), "ZERO_SIGNER");
        external_signer = new_signer;
        emit SetSigner(new_signer);
    }

    function changeClaimer(address new_claimer) external onlyOwner {
        require(new_claimer != address(0), "ZERO_claimer");
        claimer = new_claimer;
        emit SetClaimer(new_claimer);
    }

    function makeTransfer(
        address to,
        uint256 amount
    ) private returns (bool success) {
        return
            tokenCall(
                abi.encodeWithSelector(
                    paymentToken.transfer.selector,
                    to,
                    amount
                )
            );
    }

    function makeTransferFrom(
        address from,
        address to,
        uint256 amount
    ) private returns (bool success) {
        return
            tokenCall(
                abi.encodeWithSelector(
                    paymentToken.transferFrom.selector,
                    from,
                    to,
                    amount
                )
            );
    }

    function tokenCall(bytes memory data) private returns (bool) {
        (bool success, bytes memory returndata) = address(paymentToken).call(data);
        if (success) { 
            if (returndata.length > 0) {
                success = abi.decode(returndata, (bool));
            } else {
                success = address(paymentToken).code.length > 0;
            }
        }
        return success;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.0;

import "ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "ECDSA.sol";
import "EIP712.sol";

contract EIP712Verifier is EIP712 {
    address public external_signer;

    constructor(string memory domainName, string memory version, address signer) EIP712(domainName, version) {
        external_signer = signer;
        require(signer != address(0), "ZERO_SIGNER");
    }

    /* 
        Standard EIP712 verifier but with different v combinations
    */
    function verify(bytes32 digest, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {

        address recovered_signer = ecrecover(digest, v, r, s);
        if (recovered_signer != external_signer) {
            uint8 other_v = 27;
            if (other_v == v) {
                other_v = 28;
            }

            recovered_signer = ecrecover(digest, other_v, r, s);
        }

        if (recovered_signer != external_signer) {
            return false;
        }

        return true;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address","name":"_claimer","type":"address"},{"internalType":"address","name":"_paymentToken","type":"address"},{"internalType":"address","name":"_points","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ClaimedYield","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimer","type":"address"}],"name":"SetClaimer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"}],"name":"SetSigner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"SetToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawTo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawalReceipt","type":"event"},{"inputs":[],"name":"BLAST","outputs":[{"internalType":"contract IBlast","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"new_claimer","type":"address"}],"name":"changeClaimer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"new_signer","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"external_signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paymentToken","outputs":[{"internalType":"contract IERC20Rebasing","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"processedWithdrawals","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_paymentToken","type":"address"}],"name":"setPaymentToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdrawTokensTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc2000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc2000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc200000000000000000000000043000000000000000000000000000000000000030000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd800

-----Decoded View---------------
Arg [0] : _owner (address): 0xfa894dEA8da46dda595c3aF2960704226f8d6Cc2
Arg [1] : _signer (address): 0xfa894dEA8da46dda595c3aF2960704226f8d6Cc2
Arg [2] : _claimer (address): 0xfa894dEA8da46dda595c3aF2960704226f8d6Cc2
Arg [3] : _paymentToken (address): 0x4300000000000000000000000000000000000003
Arg [4] : _points (address): 0x2536FE9ab3F511540F2f9e2eC2A805005C3Dd800

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc2
Arg [1] : 000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc2
Arg [2] : 000000000000000000000000fa894dea8da46dda595c3af2960704226f8d6cc2
Arg [3] : 0000000000000000000000004300000000000000000000000000000000000003
Arg [4] : 0000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd800

822:6037:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;139:30:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5527:199:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1167:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2720:543;;;:::i;:::-;;3387:927;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4320:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1102:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1014:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3269:112;;;:::i;:::-;;5321:200;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4656:342;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5004:307;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1139:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1255:52;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;139:30:3;;;;;;;;;;;;:::o;5527:199:0:-;1877:5;1863:19;;:10;:19;;;1855:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;5631:1:::1;5608:25;;:11;:25;;::::0;5600:50:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;5670:11;5660:7;;:21;;;;;;;;;;;;;;;;;;5707:11;5696:23;;;;;;;;;;;;5527:199:::0;:::o;1167:34::-;;;;;;;;;;;;;:::o;2720:543::-;888:1;2066:17;;:29;2058:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;921:1;2120:17;:26;;;;1976:7:::1;;;;;;;;;;;1962:21;;:10;:21;;;1954:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;2786:17:::2;2806:12;;;;;;;;;;;:31;;;2846:4;2806:46;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2786:66;;963:4;2866:9;:27;2862:395;;;2909:21;2933:12;;;;;;;;;;;:22;;;2964:4;2933:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2909:61;;2984:12;;;;;;;;;;;:18;;;3011:4;3018:9;2984:44;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3042:20;3065:12;;;;;;;;;;;:22;;;3096:4;3065:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3042:60;;3139:13;3124:12;:28;3116:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;3204:42;3232:13;3217:12;:28;;;;:::i;:::-;3204:42;;;;;;:::i;:::-;;;;;;;;2895:362;;2862:395;2776:487;888:1:::0;2167:17;:28;;;;2720:543::o;3387:927::-;888:1;2066:17;;:29;2058:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;921:1;2120:17;:26;;;;3583:1:::1;3574:6;:10;3566:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;3647:5;3619:33;;:20;:24;3640:2;3619:24;;;;;;;;;;;;;;;;;;;;;:33;;;3611:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;3711:4;3684:20;:24;3705:2;3684:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;3725:14;3742:322;3831:111;3964:2;3988:6;4016;3799:241;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3772:282;;;;;;3742:16;:322::i;:::-;3725:339;;4075:10;4088:23;4095:6;4103:1;4106;4109;4088:6;:23::i;:::-;4075:36;;4129:5;4121:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;4194:6;4172:37;;4190:2;4172:37;4202:6;4172:37;;;;;;:::i;:::-;;;;;;;;4219:12;4234:28;4247:6;4255;4234:12;:28::i;:::-;4219:43;;4280:7;4272:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;3556:758;;;888:1:::0;2167:17;:28;;;;3387:927;;;;;;:::o;4320:166::-;1877:5;1863:19;;:10;:19;;;1855:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;4427:13:::1;4397:12;;:44;;;;;;;;;;;;;;;;;;4465:13;4456:23;;;;;;;;;;;;4320:166:::0;:::o;1102:30::-;;;:::o;1014:81::-;1052:42;1014:81;:::o;3269:112::-;888:1;2066:17;;:29;2058:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;921:1;2120:17;:26;;;;1976:7:::1;;;;;;;;;;;1962:21;;:10;:21;;;1954:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;1052:42:::2;3333:17;;;3359:4;3366:7;;;;;;;;;;;3333:41;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;888:1:::0;2167:17;:28;;;;3269:112::o;5321:200::-;1877:5;1863:19;;:10;:19;;;1855:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;5422:1:::1;5400:24;;:10;:24;;::::0;5392:48:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;5468:10;5450:15;::::0;:28:::1;;;;;;;;;;;;;;;;;;5503:10;5493:21;;;;;;;;;;;;5321:200:::0;:::o;4656:342::-;888:1;2066:17;;:29;2058:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;921:1;2120:17;:26;;;;1004:4:::1;4729:6;:21;;4721:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;4777:12;4792:52;4809:10;4829:4;4837:6;4792:16;:52::i;:::-;4777:67;;4862:7;4854:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;4899:17;4919:19;:17;:19::i;:::-;4899:39;;4972:10;4953:38;;4961:9;4953:38;4984:6;4953:38;;;;;;:::i;:::-;;;;;;;;4711:287;;888:1:::0;2167:17;:28;;;;4656:342;:::o;5004:307::-;1877:5;1863:19;;:10;:19;;;1855:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;5104:1:::1;5095:6;:10;5087:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;5154:1;5140:16;;:2;:16;;::::0;5132:41:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;5183:12;5198:24;5211:2;5215:6;5198:12;:24::i;:::-;5183:39;;5240:7;5232:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;5293:2;5282:22;;;5297:6;5282:22;;;;;;:::i;:::-;;;;;;;;5077:234;5004:307:::0;;:::o;1139:22::-;;;;;;;;;;;;;:::o;1255:52::-;;;;;;;;;;;;;;;;;;;;;;:::o;4346:165:2:-;4423:7;4449:55;4471:20;:18;:20::i;:::-;4493:10;4449:21;:55::i;:::-;4442:62;;4346:165;;;:::o;464:508:3:-;550:4;567:24;594:26;604:6;612:1;615;618;594:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;567:53;;654:15;;;;;;;;;;634:35;;:16;:35;;;630:226;;685:13;701:2;685:18;;732:1;721:12;;:7;:12;;;717:63;;763:2;753:12;;717:63;813:32;823:6;831:7;840:1;843;813:32;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;794:51;;671:185;630:226;890:15;;;;;;;;;;870:35;;:16;:35;;;866:78;;928:5;921:12;;;;;866:78;961:4;954:11;;;464:508;;;;;;;:::o;5732:324:0:-;5821:12;5864:185;5935:30;;;5987:2;6011:6;5891:144;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5864:9;:185::i;:::-;5845:204;;5732:324;;;;:::o;6062:380::-;6177:12;6220:215;6291:34;;;6347:4;6373:2;6397:6;6247:174;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6220:9;:215::i;:::-;6201:234;;6062:380;;;;;:::o;4492:158::-;4538:17;4579:13;;4567:25;;4602:13;;:15;;;;;;;;;:::i;:::-;;;;;;4492:158;:::o;3150:308:2:-;3203:7;3243:12;3226:29;;3234:4;3226:29;;;:66;;;;;3276:16;3259:13;:33;3226:66;3222:230;;;3315:24;3308:31;;;;3222:230;3377:64;3399:10;3411:12;3425:15;3377:21;:64::i;:::-;3370:71;;3150:308;;:::o;8338:194:1:-;8431:7;8496:15;8513:10;8467:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;8457:68;;;;;;8450:75;;8338:194;;;;:::o;6448:409:0:-;6503:4;6520:12;6534:23;6569:12;;;;;;;;;;;6561:26;;6588:4;6561:32;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6519:74;;;;6607:7;6603:224;;;6655:1;6635:10;:17;:21;6631:186;;;6697:10;6686:30;;;;;;;;;;;;:::i;:::-;6676:40;;6631:186;;;6801:1;6773:12;;;;;;;;;;;6765:33;;;:37;6755:47;;6631:186;6603:224;6843:7;6836:14;;;;6448:409;;;:::o;3464:257:2:-;3604:7;3651:8;3661;3671:11;3684:13;3707:4;3640:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3630:84;;;;;;3623:91;;3464:257;;;;;:::o;7:126:7:-;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:60::-;1556:3;1577:5;1570:12;;1528:60;;;:::o;1594:142::-;1644:9;1677:53;1695:34;1704:24;1722:5;1704:24;:::i;:::-;1695:34;:::i;:::-;1677:53;:::i;:::-;1664:66;;1594:142;;;:::o;1742:126::-;1792:9;1825:37;1856:5;1825:37;:::i;:::-;1812:50;;1742:126;;;:::o;1874:147::-;1945:9;1978:37;2009:5;1978:37;:::i;:::-;1965:50;;1874:147;;;:::o;2027:173::-;2135:58;2187:5;2135:58;:::i;:::-;2130:3;2123:71;2027:173;;:::o;2206:264::-;2320:4;2358:2;2347:9;2343:18;2335:26;;2371:92;2460:1;2449:9;2445:17;2436:6;2371:92;:::i;:::-;2206:264;;;;:::o;2476:77::-;2513:7;2542:5;2531:16;;2476:77;;;:::o;2559:122::-;2632:24;2650:5;2632:24;:::i;:::-;2625:5;2622:35;2612:63;;2671:1;2668;2661:12;2612:63;2559:122;:::o;2687:139::-;2733:5;2771:6;2758:20;2749:29;;2787:33;2814:5;2787:33;:::i;:::-;2687:139;;;;:::o;2832:86::-;2867:7;2907:4;2900:5;2896:16;2885:27;;2832:86;;;:::o;2924:118::-;2995:22;3011:5;2995:22;:::i;:::-;2988:5;2985:33;2975:61;;3032:1;3029;3022:12;2975:61;2924:118;:::o;3048:135::-;3092:5;3130:6;3117:20;3108:29;;3146:31;3171:5;3146:31;:::i;:::-;3048:135;;;;:::o;3189:77::-;3226:7;3255:5;3244:16;;3189:77;;;:::o;3272:122::-;3345:24;3363:5;3345:24;:::i;:::-;3338:5;3335:35;3325:63;;3384:1;3381;3374:12;3325:63;3272:122;:::o;3400:139::-;3446:5;3484:6;3471:20;3462:29;;3500:33;3527:5;3500:33;:::i;:::-;3400:139;;;;:::o;3545:1053::-;3647:6;3655;3663;3671;3679;3687;3736:3;3724:9;3715:7;3711:23;3707:33;3704:120;;;3743:79;;:::i;:::-;3704:120;3863:1;3888:53;3933:7;3924:6;3913:9;3909:22;3888:53;:::i;:::-;3878:63;;3834:117;3990:2;4016:53;4061:7;4052:6;4041:9;4037:22;4016:53;:::i;:::-;4006:63;;3961:118;4118:2;4144:53;4189:7;4180:6;4169:9;4165:22;4144:53;:::i;:::-;4134:63;;4089:118;4246:2;4272:51;4315:7;4306:6;4295:9;4291:22;4272:51;:::i;:::-;4262:61;;4217:116;4372:3;4399:53;4444:7;4435:6;4424:9;4420:22;4399:53;:::i;:::-;4389:63;;4343:119;4501:3;4528:53;4573:7;4564:6;4553:9;4549:22;4528:53;:::i;:::-;4518:63;;4472:119;3545:1053;;;;;;;;:::o;4604:139::-;4667:9;4700:37;4731:5;4700:37;:::i;:::-;4687:50;;4604:139;;;:::o;4749:157::-;4849:50;4893:5;4849:50;:::i;:::-;4844:3;4837:63;4749:157;;:::o;4912:248::-;5018:4;5056:2;5045:9;5041:18;5033:26;;5069:84;5150:1;5139:9;5135:17;5126:6;5069:84;:::i;:::-;4912:248;;;;:::o;5166:329::-;5225:6;5274:2;5262:9;5253:7;5249:23;5245:32;5242:119;;;5280:79;;:::i;:::-;5242:119;5400:1;5425:53;5470:7;5461:6;5450:9;5446:22;5425:53;:::i;:::-;5415:63;;5371:117;5166:329;;;;:::o;5501:474::-;5569:6;5577;5626:2;5614:9;5605:7;5601:23;5597:32;5594:119;;;5632:79;;:::i;:::-;5594:119;5752:1;5777:53;5822:7;5813:6;5802:9;5798:22;5777:53;:::i;:::-;5767:63;;5723:117;5879:2;5905:53;5950:7;5941:6;5930:9;5926:22;5905:53;:::i;:::-;5895:63;;5850:118;5501:474;;;;;:::o;5981:90::-;6015:7;6058:5;6051:13;6044:21;6033:32;;5981:90;;;:::o;6077:109::-;6158:21;6173:5;6158:21;:::i;:::-;6153:3;6146:34;6077:109;;:::o;6192:210::-;6279:4;6317:2;6306:9;6302:18;6294:26;;6330:65;6392:1;6381:9;6377:17;6368:6;6330:65;:::i;:::-;6192:210;;;;:::o;6408:169::-;6492:11;6526:6;6521:3;6514:19;6566:4;6561:3;6557:14;6542:29;;6408:169;;;;:::o;6583:160::-;6723:12;6719:1;6711:6;6707:14;6700:36;6583:160;:::o;6749:366::-;6891:3;6912:67;6976:2;6971:3;6912:67;:::i;:::-;6905:74;;6988:93;7077:3;6988:93;:::i;:::-;7106:2;7101:3;7097:12;7090:19;;6749:366;;;:::o;7121:419::-;7287:4;7325:2;7314:9;7310:18;7302:26;;7374:9;7368:4;7364:20;7360:1;7349:9;7345:17;7338:47;7402:131;7528:4;7402:131;:::i;:::-;7394:139;;7121:419;;;:::o;7546:162::-;7686:14;7682:1;7674:6;7670:14;7663:38;7546:162;:::o;7714:366::-;7856:3;7877:67;7941:2;7936:3;7877:67;:::i;:::-;7870:74;;7953:93;8042:3;7953:93;:::i;:::-;8071:2;8066:3;8062:12;8055:19;;7714:366;;;:::o;8086:419::-;8252:4;8290:2;8279:9;8275:18;8267:26;;8339:9;8333:4;8329:20;8325:1;8314:9;8310:17;8303:47;8367:131;8493:4;8367:131;:::i;:::-;8359:139;;8086:419;;;:::o;8511:160::-;8651:12;8647:1;8639:6;8635:14;8628:36;8511:160;:::o;8677:366::-;8819:3;8840:67;8904:2;8899:3;8840:67;:::i;:::-;8833:74;;8916:93;9005:3;8916:93;:::i;:::-;9034:2;9029:3;9025:12;9018:19;;8677:366;;;:::o;9049:419::-;9215:4;9253:2;9242:9;9238:18;9230:26;;9302:9;9296:4;9292:20;9288:1;9277:9;9273:17;9266:47;9330:131;9456:4;9330:131;:::i;:::-;9322:139;;9049:419;;;:::o;9474:162::-;9614:14;9610:1;9602:6;9598:14;9591:38;9474:162;:::o;9642:366::-;9784:3;9805:67;9869:2;9864:3;9805:67;:::i;:::-;9798:74;;9881:93;9970:3;9881:93;:::i;:::-;9999:2;9994:3;9990:12;9983:19;;9642:366;;;:::o;10014:419::-;10180:4;10218:2;10207:9;10203:18;10195:26;;10267:9;10261:4;10257:20;10253:1;10242:9;10238:17;10231:47;10295:131;10421:4;10295:131;:::i;:::-;10287:139;;10014:419;;;:::o;10439:143::-;10496:5;10527:6;10521:13;10512:22;;10543:33;10570:5;10543:33;:::i;:::-;10439:143;;;;:::o;10588:351::-;10658:6;10707:2;10695:9;10686:7;10682:23;10678:32;10675:119;;;10713:79;;:::i;:::-;10675:119;10833:1;10858:64;10914:7;10905:6;10894:9;10890:22;10858:64;:::i;:::-;10848:74;;10804:128;10588:351;;;;:::o;10945:118::-;11032:24;11050:5;11032:24;:::i;:::-;11027:3;11020:37;10945:118;;:::o;11069:332::-;11190:4;11228:2;11217:9;11213:18;11205:26;;11241:71;11309:1;11298:9;11294:17;11285:6;11241:71;:::i;:::-;11322:72;11390:2;11379:9;11375:18;11366:6;11322:72;:::i;:::-;11069:332;;;;;:::o;11407:178::-;11547:30;11543:1;11535:6;11531:14;11524:54;11407:178;:::o;11591:366::-;11733:3;11754:67;11818:2;11813:3;11754:67;:::i;:::-;11747:74;;11830:93;11919:3;11830:93;:::i;:::-;11948:2;11943:3;11939:12;11932:19;;11591:366;;;:::o;11963:419::-;12129:4;12167:2;12156:9;12152:18;12144:26;;12216:9;12210:4;12206:20;12202:1;12191:9;12187:17;12180:47;12244:131;12370:4;12244:131;:::i;:::-;12236:139;;11963:419;;;:::o;12388:180::-;12436:77;12433:1;12426:88;12533:4;12530:1;12523:15;12557:4;12554:1;12547:15;12574:194;12614:4;12634:20;12652:1;12634:20;:::i;:::-;12629:25;;12668:20;12686:1;12668:20;:::i;:::-;12663:25;;12712:1;12709;12705:9;12697:17;;12736:1;12730:4;12727:11;12724:37;;;12741:18;;:::i;:::-;12724:37;12574:194;;;;:::o;12774:222::-;12867:4;12905:2;12894:9;12890:18;12882:26;;12918:71;12986:1;12975:9;12971:17;12962:6;12918:71;:::i;:::-;12774:222;;;;:::o;13002:162::-;13142:14;13138:1;13130:6;13126:14;13119:38;13002:162;:::o;13170:366::-;13312:3;13333:67;13397:2;13392:3;13333:67;:::i;:::-;13326:74;;13409:93;13498:3;13409:93;:::i;:::-;13527:2;13522:3;13518:12;13511:19;;13170:366;;;:::o;13542:419::-;13708:4;13746:2;13735:9;13731:18;13723:26;;13795:9;13789:4;13785:20;13781:1;13770:9;13766:17;13759:47;13823:131;13949:4;13823:131;:::i;:::-;13815:139;;13542:419;;;:::o;13967:167::-;14107:19;14103:1;14095:6;14091:14;14084:43;13967:167;:::o;14140:366::-;14282:3;14303:67;14367:2;14362:3;14303:67;:::i;:::-;14296:74;;14379:93;14468:3;14379:93;:::i;:::-;14497:2;14492:3;14488:12;14481:19;;14140:366;;;:::o;14512:419::-;14678:4;14716:2;14705:9;14701:18;14693:26;;14765:9;14759:4;14755:20;14751:1;14740:9;14736:17;14729:47;14793:131;14919:4;14793:131;:::i;:::-;14785:139;;14512:419;;;:::o;14937:118::-;15024:24;15042:5;15024:24;:::i;:::-;15019:3;15012:37;14937:118;;:::o;15061:553::-;15238:4;15276:3;15265:9;15261:19;15253:27;;15290:71;15358:1;15347:9;15343:17;15334:6;15290:71;:::i;:::-;15371:72;15439:2;15428:9;15424:18;15415:6;15371:72;:::i;:::-;15453;15521:2;15510:9;15506:18;15497:6;15453:72;:::i;:::-;15535;15603:2;15592:9;15588:18;15579:6;15535:72;:::i;:::-;15061:553;;;;;;;:::o;15620:167::-;15760:19;15756:1;15748:6;15744:14;15737:43;15620:167;:::o;15793:366::-;15935:3;15956:67;16020:2;16015:3;15956:67;:::i;:::-;15949:74;;16032:93;16121:3;16032:93;:::i;:::-;16150:2;16145:3;16141:12;16134:19;;15793:366;;;:::o;16165:419::-;16331:4;16369:2;16358:9;16354:18;16346:26;;16418:9;16412:4;16408:20;16404:1;16393:9;16389:17;16382:47;16446:131;16572:4;16446:131;:::i;:::-;16438:139;;16165:419;;;:::o;16590:165::-;16730:17;16726:1;16718:6;16714:14;16707:41;16590:165;:::o;16761:366::-;16903:3;16924:67;16988:2;16983:3;16924:67;:::i;:::-;16917:74;;17000:93;17089:3;17000:93;:::i;:::-;17118:2;17113:3;17109:12;17102:19;;16761:366;;;:::o;17133:419::-;17299:4;17337:2;17326:9;17322:18;17314:26;;17386:9;17380:4;17376:20;17372:1;17361:9;17357:17;17350:47;17414:131;17540:4;17414:131;:::i;:::-;17406:139;;17133:419;;;:::o;17558:332::-;17679:4;17717:2;17706:9;17702:18;17694:26;;17730:71;17798:1;17787:9;17783:17;17774:6;17730:71;:::i;:::-;17811:72;17879:2;17868:9;17864:18;17855:6;17811:72;:::i;:::-;17558:332;;;;;:::o;17896:161::-;18036:13;18032:1;18024:6;18020:14;18013:37;17896:161;:::o;18063:366::-;18205:3;18226:67;18290:2;18285:3;18226:67;:::i;:::-;18219:74;;18302:93;18391:3;18302:93;:::i;:::-;18420:2;18415:3;18411:12;18404:19;;18063:366;;;:::o;18435:419::-;18601:4;18639:2;18628:9;18624:18;18616:26;;18688:9;18682:4;18678:20;18674:1;18663:9;18659:17;18652:47;18716:131;18842:4;18716:131;:::i;:::-;18708:139;;18435:419;;;:::o;18860:162::-;19000:14;18996:1;18988:6;18984:14;18977:38;18860:162;:::o;19028:366::-;19170:3;19191:67;19255:2;19250:3;19191:67;:::i;:::-;19184:74;;19267:93;19356:3;19267:93;:::i;:::-;19385:2;19380:3;19376:12;19369:19;;19028:366;;;:::o;19400:419::-;19566:4;19604:2;19593:9;19589:18;19581:26;;19653:9;19647:4;19643:20;19639:1;19628:9;19624:17;19617:47;19681:131;19807:4;19681:131;:::i;:::-;19673:139;;19400:419;;;:::o;19825:112::-;19908:22;19924:5;19908:22;:::i;:::-;19903:3;19896:35;19825:112;;:::o;19943:545::-;20116:4;20154:3;20143:9;20139:19;20131:27;;20168:71;20236:1;20225:9;20221:17;20212:6;20168:71;:::i;:::-;20249:68;20313:2;20302:9;20298:18;20289:6;20249:68;:::i;:::-;20327:72;20395:2;20384:9;20380:18;20371:6;20327:72;:::i;:::-;20409;20477:2;20466:9;20462:18;20453:6;20409:72;:::i;:::-;19943:545;;;;;;;:::o;20494:442::-;20643:4;20681:2;20670:9;20666:18;20658:26;;20694:71;20762:1;20751:9;20747:17;20738:6;20694:71;:::i;:::-;20775:72;20843:2;20832:9;20828:18;20819:6;20775:72;:::i;:::-;20857;20925:2;20914:9;20910:18;20901:6;20857:72;:::i;:::-;20494:442;;;;;;:::o;20942:233::-;20981:3;21004:24;21022:5;21004:24;:::i;:::-;20995:33;;21050:66;21043:5;21040:77;21037:103;;21120:18;;:::i;:::-;21037:103;21167:1;21160:5;21156:13;21149:20;;20942:233;;;:::o;21181:148::-;21283:11;21320:3;21305:18;;21181:148;;;;:::o;21335:214::-;21475:66;21471:1;21463:6;21459:14;21452:90;21335:214;:::o;21555:400::-;21715:3;21736:84;21818:1;21813:3;21736:84;:::i;:::-;21729:91;;21829:93;21918:3;21829:93;:::i;:::-;21947:1;21942:3;21938:11;21931:18;;21555:400;;;:::o;21961:79::-;22000:7;22029:5;22018:16;;21961:79;;;:::o;22046:157::-;22151:45;22171:24;22189:5;22171:24;:::i;:::-;22151:45;:::i;:::-;22146:3;22139:58;22046:157;;:::o;22209:663::-;22450:3;22472:148;22616:3;22472:148;:::i;:::-;22465:155;;22630:75;22701:3;22692:6;22630:75;:::i;:::-;22730:2;22725:3;22721:12;22714:19;;22743:75;22814:3;22805:6;22743:75;:::i;:::-;22843:2;22838:3;22834:12;22827:19;;22863:3;22856:10;;22209:663;;;;;:::o;22878:98::-;22929:6;22963:5;22957:12;22947:22;;22878:98;;;:::o;22982:147::-;23083:11;23120:3;23105:18;;22982:147;;;;:::o;23135:246::-;23216:1;23226:113;23240:6;23237:1;23234:13;23226:113;;;23325:1;23320:3;23316:11;23310:18;23306:1;23301:3;23297:11;23290:39;23262:2;23259:1;23255:10;23250:15;;23226:113;;;23373:1;23364:6;23359:3;23355:16;23348:27;23197:184;23135:246;;;:::o;23387:386::-;23491:3;23519:38;23551:5;23519:38;:::i;:::-;23573:88;23654:6;23649:3;23573:88;:::i;:::-;23566:95;;23670:65;23728:6;23723:3;23716:4;23709:5;23705:16;23670:65;:::i;:::-;23760:6;23755:3;23751:16;23744:23;;23495:278;23387:386;;;;:::o;23779:271::-;23909:3;23931:93;24020:3;24011:6;23931:93;:::i;:::-;23924:100;;24041:3;24034:10;;23779:271;;;;:::o;24056:116::-;24126:21;24141:5;24126:21;:::i;:::-;24119:5;24116:32;24106:60;;24162:1;24159;24152:12;24106:60;24056:116;:::o;24178:137::-;24232:5;24263:6;24257:13;24248:22;;24279:30;24303:5;24279:30;:::i;:::-;24178:137;;;;:::o;24321:345::-;24388:6;24437:2;24425:9;24416:7;24412:23;24408:32;24405:119;;;24443:79;;:::i;:::-;24405:119;24563:1;24588:61;24641:7;24632:6;24621:9;24617:22;24588:61;:::i;:::-;24578:71;;24534:125;24321:345;;;;:::o;24672:664::-;24877:4;24915:3;24904:9;24900:19;24892:27;;24929:71;24997:1;24986:9;24982:17;24973:6;24929:71;:::i;:::-;25010:72;25078:2;25067:9;25063:18;25054:6;25010:72;:::i;:::-;25092;25160:2;25149:9;25145:18;25136:6;25092:72;:::i;:::-;25174;25242:2;25231:9;25227:18;25218:6;25174:72;:::i;:::-;25256:73;25324:3;25313:9;25309:19;25300:6;25256:73;:::i;:::-;24672:664;;;;;;;;:::o

ipfs://edb977f146a7f3945d3bc41573e03df83606dfc004f98156a752931089aeb28e