Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: None
pragma solidity ^0.8.29;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;

struct BeneficiaryPercent {
    address beneficiary; // Beneficiary's address
    uint256 percent; // Benefit ratio, 1e18 = 100%
}

struct Asset {
    uint248 releaseTime; // Next release time
    bool isFinanced;
    EnumerableSet.AddressSet tokenSet;
    mapping(address => uint256) balanceMap;
}

struct BeneficiaryMap {
    EnumerableSet.AddressSet beneficiarySet; // Beneficiary's address set
    mapping(address => uint256) percentMap; // Benefit ratio map (The sum must be 100%), 1e18 = 100%
}

struct BenefitStatus {
    EnumerableSet.AddressSet claimableTokenSet;
    EnumerableSet.AddressSet claimableFinancedTokenSet;
    mapping(address => uint256) claimableBalanceMap;
    mapping(address => uint256) claimableFinancedBalanceMap;
    EnumerableSet.AddressSet effectiveSettlors;
}

struct BasicAsset {
    uint248 releaseTime;
    bool isFinanced;
    address[] tokens;
    uint256[] balances;
    uint256[] sumActualBalances;
    uint256[] sumRecordBalances;
    uint256[] sumInterestBases;
}

struct LegacyOrTrust {
    BasicAsset basicAsset;
    address[] beneficiaries;
    uint256[] percentages;
}

struct Pension {
    BasicAsset basicAsset;
    uint256 releaseMonths;
}

struct BenefitAsset {
    address[] claimableTokens;
    uint256[] claimableBalances;
    address[] claimableFinancedTokens;
    uint256[] claimableFinancedBalances;
    uint256[] sumActualBalances;
    uint256[] sumRecordBalances;
    uint256[] sumInterestBases;
}

struct FinParam {
    uint256 interestFeeRate;
    address financeContractAddress;
    address receiver1;
    address receiver2;
}

struct Vars {
    uint256 sumActual;
    uint256 sumRecord;
    uint256 balance;
}

struct TmpVars1 {
    address token;
    uint256 sumInterestBase;
    uint256 interestFee;
    uint256 record;
    uint256 feeRecord;
    uint256 withdrawFee;
}

struct TmpVars2 {
    uint256 sumActualNew;
    uint256 record;
    uint256 amount;
    uint256 withdrawFee;
}

struct Store {
    uint256 interestFeeRate; // Service fee rate based on financial profit, 1e18 = 100%
    address financeContractAddress;
    address receiver1;
    address receiver2;
    mapping(address => bool) isTokenSupported;
    mapping(address => bool) isTokenFinancingPaused;
    mapping(address => uint256) pausingFinancedActualMap;
    mapping(address => uint256) sumFinancedRecordMap;
    mapping(address => uint256) sumInterestBaseMap;
    mapping(address => uint256) pensionReleaseMonths; // Months of pension payment remaining (1 ~ MONTHS_RELEASE_MAX)
    mapping(address => Asset)[3] assets;
    mapping(address => BeneficiaryMap)[2] beneficiaryMaps;
    mapping(address => BenefitStatus)[2] benefitStatuses;
    mapping(address => EnumerableSet.AddressSet)[3] financedTokenSettlors;
    mapping(address => EnumerableSet.AddressSet)[2] financedTokenBeneficiaries;
}

enum OperationType {
    Deposit,
    Withdraw,
    Execute
}

error TotalPercentNot100(); // The benefit ratio does not add up to 100%
error RateExceeds100Percent();
error AlreadyExists(); // Trust already exists and cannot be created repeatedly until the assets are cleared
error NotExists(); // This asset does not exist or has been terminated
error OnlyOwnerCanCall();
error OnlyCallBeforeRelease(); // It can only be called before the release time, but the current time has reached the release time, or this asset has not been created
error OnlyCallAfterRelease(); // It can only be called after the release time, but the current time has not reached the release time, or this asset has not been created
error InvalidReleaseTime(); // Must be no earlier than the current time - 30 days, and pension must also be no later than the current time + 50 years
error InvalidReleaseMonths(); // 1 ~ MONTHS_RELEASE_MAX
error BeneficiaryDuplicated(); // Beneficiary's address duplicated
error TokenNotSupported();
error VerificationFailed(); // The balance decreases after the withdrawal of financial assets, or financeContract.tokenGuardContract is not address of this

event AssetCreated(
    uint256 indexed assetMode,
    address indexed settlor,
    uint248 releaseTime,
    uint256 releaseMonths,
    uint256 timestamp
);
event AssetOperation(
    uint256 indexed assetMode,
    address indexed settlor,
    OperationType indexed operationType,
    address token,
    uint256 amount,
    uint256 timestamp
); // Asset operation record (Deposit, Withdraw, Execute)
event Claimed(
    uint256 indexed assetMode,
    address indexed beneficiary,
    address indexed token,
    uint256 amount,
    uint256 timestamp
); // Pension does not emit the event
event AssetTerminated(
    uint256 indexed assetMode,
    address indexed settlor,
    uint256 timestamp
);
event FinanceChanged(
    uint256 indexed assetMode,
    address indexed settlor,
    bool indexed isFinanced,
    uint256 timestamp
); // Financial status update (This event will be emitted if financial is enabled when the asset is created, and will be emitted if financial is disabled when the asset is terminated)
event AssetReleaseTimeUpdated(
    uint256 indexed assetMode,
    address indexed settlor,
    uint248 releaseTime,
    uint256 timestamp
); // This event will not be emitted when the asset is created or terminated
event FeePaid(
    uint256 indexed assetMode,
    address indexed settlor,
    address indexed token,
    uint256 amount,
    uint256 timestamp
); // Management fee on withdrawals paid
event InterestFeePaid(
    address indexed token,
    uint256 amount,
    uint256 financeContractBalance, // The balance of the financial contract before the interest fee charged
    uint256 timestamp
); // Service fee rate based on financial profit paid

uint256 constant PERCENTAGE_BASE = 1e18; // 100%
uint256 constant PERCENTAGE_SQUARE = 1e36; // PERCENTAGE_BASE squared
uint256 constant FEE_DIVISOR = 50; // Management fee on withdrawals, 2%
uint256 constant REMAIN_AFTER_FEE = 98e16; // 98%
uint248 constant SECONDS_PER_MONTH = 2592000; // The number of seconds in 30 days
uint256 constant SECONDS_LOCK_MAX = 1577923200; // Maximum locking seconds of pension (50 years, 60 * 60 * 24 * (365 * 50 + 13 leap days))
uint256 constant MONTHS_RELEASE_MAX = 360; // Maximum months of pension payment
uint256 constant LEGACY = 0;
uint256 constant TRUST = 1;
uint256 constant PENSION = 2;

interface IFinance {
    function balanceOf(address token) external view returns (uint256 balance);

    function deposit(address token, uint256 amount) external payable;

    function withdraw(address token, uint256 amount)
        external
        returns (uint256 withdrawAmount);

    function tokenGuardContract() external view returns (address);
}

library TokenGuardLib {
    function _getFinancedBalance(
        Store storage store,
        address token,
        address _financeContractAddress
    ) internal view returns (uint256 balance) {
        return
            store.isTokenFinancingPaused[token]
                ? store.pausingFinancedActualMap[token]
                : IFinance(_financeContractAddress).balanceOf(token);
    }

    function _getFinancedBalanceWithFlag(
        Store storage store,
        address token,
        address _financeContractAddress,
        bool notQueryFinancedBalance
    ) internal view returns (uint256 balance) {
        return
            store.isTokenFinancingPaused[token]
                ? store.pausingFinancedActualMap[token]
                : notQueryFinancedBalance
                ? 0
                : IFinance(_financeContractAddress).balanceOf(token);
    }

    function _getSumFinancedActualMapAll(
        Store storage store,
        address[] storage supportedTokens,
        bool notQueryFinancedBalance
    )
        external
        view
        returns (address[] memory tokens, uint256[] memory balances)
    {
        tokens = supportedTokens;
        balances = new uint256[](tokens.length);
        address _financeContractAddress = store.financeContractAddress;
        for (uint256 i = 0; i < tokens.length; i++)
            balances[i] = _getFinancedBalanceWithFlag(
                store,
                tokens[i],
                _financeContractAddress,
                notQueryFinancedBalance
            );
    }

    function _getFinancedTransform(
        Store storage store,
        address[] storage supportedTokens,
        bool notQueryFinancedBalance
    )
        external
        view
        returns (
            address[] memory tokens,
            uint256[] memory sumActualBalances,
            uint256[] memory sumRecordBalances,
            uint256[] memory sumInterestBases
        )
    {
        tokens = supportedTokens;
        sumActualBalances = new uint256[](tokens.length);
        sumRecordBalances = new uint256[](tokens.length);
        sumInterestBases = new uint256[](tokens.length);
        address _financeContractAddress = store.financeContractAddress;
        for (uint256 i = 0; i < tokens.length; i++) {
            sumActualBalances[i] = _getFinancedBalanceWithFlag(
                store,
                tokens[i],
                _financeContractAddress,
                notQueryFinancedBalance
            );
            sumRecordBalances[i] = store.sumFinancedRecordMap[tokens[i]];
            sumInterestBases[i] = store.sumInterestBaseMap[tokens[i]];
        }
    }

    function _getAsset(
        Store storage store,
        uint256 assetMode,
        address settlor,
        bool notQueryFinancedBalance
    ) internal view returns (BasicAsset memory basicAsset) {
        basicAsset.releaseTime = store.assets[assetMode][settlor].releaseTime;
        basicAsset.isFinanced = store.assets[assetMode][settlor].isFinanced;
        basicAsset.tokens = store.assets[assetMode][settlor].tokenSet.values();
        if (basicAsset.tokens.length > 0) {
            basicAsset.balances = new uint256[](basicAsset.tokens.length);
            if (basicAsset.isFinanced) {
                address _financeContractAddress = store.financeContractAddress;
                basicAsset.sumActualBalances = new uint256[](
                    basicAsset.tokens.length
                );
                basicAsset.sumRecordBalances = new uint256[](
                    basicAsset.tokens.length
                );
                basicAsset.sumInterestBases = new uint256[](
                    basicAsset.tokens.length
                );
                for (uint256 i = 0; i < basicAsset.tokens.length; i++) {
                    basicAsset.balances[i] = store
                    .assets[assetMode][settlor].balanceMap[
                            basicAsset.tokens[i]
                        ];
                    basicAsset.sumActualBalances[
                        i
                    ] = _getFinancedBalanceWithFlag(
                        store,
                        basicAsset.tokens[i],
                        _financeContractAddress,
                        notQueryFinancedBalance
                    );
                    basicAsset.sumRecordBalances[i] = store
                        .sumFinancedRecordMap[basicAsset.tokens[i]];
                    basicAsset.sumInterestBases[i] = store.sumInterestBaseMap[
                        basicAsset.tokens[i]
                    ];
                }
            } else
                for (uint256 i = 0; i < basicAsset.tokens.length; i++)
                    basicAsset.balances[i] = store
                    .assets[assetMode][settlor].balanceMap[
                            basicAsset.tokens[i]
                        ];
        }
    }

    function _getLegacyOrTrust(
        Store storage store,
        uint256 assetMode,
        address settlor,
        bool notQueryFinancedBalance
    ) internal view returns (LegacyOrTrust memory legacyOrTrust) {
        legacyOrTrust.basicAsset = _getAsset(
            store,
            assetMode,
            settlor,
            notQueryFinancedBalance
        );
        legacyOrTrust.beneficiaries = store
            .beneficiaryMaps[assetMode][settlor]
            .beneficiarySet
            .values();
        if (legacyOrTrust.beneficiaries.length > 0) {
            legacyOrTrust.percentages = new uint256[](
                legacyOrTrust.beneficiaries.length
            );
            for (uint256 i = 0; i < legacyOrTrust.beneficiaries.length; i++) {
                legacyOrTrust.percentages[i] = store
                .beneficiaryMaps[assetMode][settlor].percentMap[
                        legacyOrTrust.beneficiaries[i]
                    ];
            }
        }
    }

    function _getLegacyOrTrustExternal(
        Store storage store,
        uint256 assetMode,
        address settlor,
        bool notQueryFinancedBalance
    ) external view returns (LegacyOrTrust memory legacyOrTrust) {
        return
            _getLegacyOrTrust(
                store,
                assetMode,
                settlor,
                notQueryFinancedBalance
            );
    }

    function _getPension(
        Store storage store,
        address settlor,
        bool notQueryFinancedBalance
    ) external view returns (Pension memory pension) {
        pension.basicAsset = _getAsset(
            store,
            PENSION,
            settlor,
            notQueryFinancedBalance
        );
        pension.releaseMonths = store.pensionReleaseMonths[settlor];
    }

    function _getBenefitStatus(
        Store storage store,
        uint256 assetMode,
        address beneficiary,
        bool notQueryFinancedBalance
    ) public view returns (BenefitAsset memory benefitAsset) {
        benefitAsset.claimableTokens = store
            .benefitStatuses[assetMode][beneficiary]
            .claimableTokenSet
            .values();
        if (benefitAsset.claimableTokens.length > 0) {
            benefitAsset.claimableBalances = new uint256[](
                benefitAsset.claimableTokens.length
            );
            for (uint256 i = 0; i < benefitAsset.claimableTokens.length; i++) {
                benefitAsset.claimableBalances[i] = store
                .benefitStatuses[assetMode][beneficiary].claimableBalanceMap[
                        benefitAsset.claimableTokens[i]
                    ];
            }
        }
        benefitAsset.claimableFinancedTokens = store
            .benefitStatuses[assetMode][beneficiary]
            .claimableFinancedTokenSet
            .values();
        if (benefitAsset.claimableFinancedTokens.length > 0) {
            address _financeContractAddress = store.financeContractAddress;
            benefitAsset.claimableFinancedBalances = new uint256[](
                benefitAsset.claimableFinancedTokens.length
            );
            benefitAsset.sumActualBalances = new uint256[](
                benefitAsset.claimableFinancedTokens.length
            );
            benefitAsset.sumRecordBalances = new uint256[](
                benefitAsset.claimableFinancedTokens.length
            );
            benefitAsset.sumInterestBases = new uint256[](
                benefitAsset.claimableFinancedTokens.length
            );
            for (
                uint256 i = 0;
                i < benefitAsset.claimableFinancedTokens.length;
                i++
            ) {
                benefitAsset.claimableFinancedBalances[i] = store
                .benefitStatuses[assetMode][beneficiary]
                    .claimableFinancedBalanceMap[
                        benefitAsset.claimableFinancedTokens[i]
                    ];
                benefitAsset.sumActualBalances[i] = _getFinancedBalanceWithFlag(
                    store,
                    benefitAsset.claimableFinancedTokens[i],
                    _financeContractAddress,
                    notQueryFinancedBalance
                );
                benefitAsset.sumRecordBalances[i] = store.sumFinancedRecordMap[
                    benefitAsset.claimableFinancedTokens[i]
                ];
                benefitAsset.sumInterestBases[i] = store.sumInterestBaseMap[
                    benefitAsset.claimableFinancedTokens[i]
                ];
            }
        }
    }

    function _getAssetAndBenefit(
        Store storage store,
        uint256 assetMode,
        address settlorAndBeneficiary,
        bool notQueryFinancedBalance
    )
        external
        view
        returns (
            LegacyOrTrust memory legacyOrTrust,
            BenefitAsset memory benefitAsset,
            address[] memory executableSettlors,
            LegacyOrTrust[] memory executableAssets
        )
    {
        legacyOrTrust = _getLegacyOrTrust(
            store,
            assetMode,
            settlorAndBeneficiary,
            notQueryFinancedBalance
        );
        benefitAsset = _getBenefitStatus(
            store,
            assetMode,
            settlorAndBeneficiary,
            notQueryFinancedBalance
        );
        address[] memory effectiveSettlors = store
            .benefitStatuses[assetMode][settlorAndBeneficiary]
            .effectiveSettlors
            .values();
        uint256[] memory indexes = new uint256[](effectiveSettlors.length);
        uint256 executableNum;
        for (uint256 i = 0; i < effectiveSettlors.length; i++) {
            if (
                block.timestamp >=
                store.assets[assetMode][effectiveSettlors[i]].releaseTime
            ) {
                indexes[executableNum] = i;
                executableNum++;
            }
        }
        if (executableNum > 0) {
            executableSettlors = new address[](executableNum);
            executableAssets = new LegacyOrTrust[](executableNum);
            for (uint256 i = 0; i < executableNum; i++) {
                executableSettlors[i] = effectiveSettlors[indexes[i]];
                executableAssets[i] = _getLegacyOrTrust(
                    store,
                    assetMode,
                    effectiveSettlors[indexes[i]],
                    notQueryFinancedBalance
                );
            }
        }
    }

    function _transfer(
        address receiver,
        address token,
        uint256 amount
    ) internal {
        if (token == address(0)) payable(receiver).transfer(amount);
        else IERC20(token).safeTransfer(receiver, amount);
    }

    function _payFee(
        uint256 fee,
        address token,
        address _receiver1,
        address _receiver2
    ) internal {
        uint256 fee1 = (fee * 85) / 100;
        if (token == address(0)) {
            payable(_receiver1).transfer(fee1);
            payable(_receiver2).transfer(fee - fee1);
        } else {
            IERC20(token).safeTransfer(_receiver1, fee1);
            IERC20(token).safeTransfer(_receiver2, fee - fee1);
        }
    }

    function _payInterestFee(
        uint256 fee,
        address token,
        address _receiver1,
        address _receiver2,
        uint256 financeContractBalance
    ) internal {
        _payFee(fee, token, _receiver1, _receiver2);
        emit InterestFeePaid(
            token,
            fee,
            financeContractBalance,
            block.timestamp
        );
    }

    function _payWithdrawFee(
        uint256 fee,
        address token,
        address _receiver1,
        address _receiver2,
        address settlor,
        uint256 assetMode
    ) internal {
        _payFee(fee, token, _receiver1, _receiver2);
        emit FeePaid(assetMode, settlor, token, fee, block.timestamp);
    }

    function _payInterestFeeAndWithdrawFee(
        uint256 interestFee,
        uint256 withdrawFee,
        address token,
        address _receiver1,
        address _receiver2,
        address settlor,
        uint256 assetMode,
        uint256 financeContractBalance
    ) internal {
        _payFee(interestFee + withdrawFee, token, _receiver1, _receiver2);
        if (interestFee > 0)
            emit InterestFeePaid(
                token,
                interestFee,
                financeContractBalance,
                block.timestamp
            );
        if (withdrawFee > 0)
            emit FeePaid(
                assetMode,
                settlor,
                token,
                withdrawFee,
                block.timestamp
            );
    }

    function _calculateInterest(
        Store storage store,
        address token,
        address _financeContractAddress,
        uint256 _interestFeeRate
    )
        internal
        view
        returns (
            uint256 sumFinancedActual,
            uint256 sumInterestBase,
            uint256 fee
        )
    {
        sumInterestBase = store.sumInterestBaseMap[token];
        if (sumInterestBase > 0) {
            sumFinancedActual = _getFinancedBalance(
                store,
                token,
                _financeContractAddress
            );
            if (sumFinancedActual > sumInterestBase)
                fee =
                    ((sumFinancedActual - sumInterestBase) * _interestFeeRate) /
                    PERCENTAGE_BASE;
        }
    }

    function _financeVars(
        Store storage store,
        uint256 assetMode,
        address token,
        address settlor,
        address _financeContractAddress,
        uint256 _interestFeeRate
    )
        internal
        view
        returns (
            Vars memory vars,
            uint256 sumInterestBase,
            uint256 fee
        )
    {
        (vars.sumActual, sumInterestBase, fee) = _calculateInterest(
            store,
            token,
            _financeContractAddress,
            _interestFeeRate
        );
        vars.sumRecord = store.sumFinancedRecordMap[token];
        vars.balance = store.assets[assetMode][settlor].balanceMap[token];
    }

    function _depositToFinanceContract(
        address token,
        uint256 amount,
        address _financeContractAddress
    ) internal {
        if (token == address(0))
            IFinance(_financeContractAddress).deposit{value: amount}(
                address(0),
                amount
            );
        else {
            IERC20(token).forceApprove(_financeContractAddress, amount);
            IFinance(_financeContractAddress).deposit(token, amount);
        }
    }

    function _withdrawFromFinanceContract(
        address token,
        uint256 amount,
        address _financeContractAddress
    ) internal returns (uint256 withdrawAmount) {
        uint256 oldBalance = token == address(0)
            ? address(this).balance
            : IERC20(token).balanceOf(address(this));
        withdrawAmount = IFinance(_financeContractAddress).withdraw(
            token,
            amount
        );
        uint256 newBalance = token == address(0)
            ? address(this).balance
            : IERC20(token).balanceOf(address(this));
        if (newBalance < oldBalance) revert VerificationFailed();
        if (newBalance - oldBalance < withdrawAmount)
            withdrawAmount = newBalance - oldBalance;
    }

    function _processFinanceAsset(
        Store storage store,
        uint256 oldBalance,
        uint256 newBalance,
        uint256 assetMode,
        address settlor,
        address token
    ) internal {
        if (newBalance != oldBalance) {
            if (newBalance == 0) {
                store.assets[assetMode][settlor].tokenSet.remove(token);
                store.financedTokenSettlors[assetMode][token].remove(settlor);
            } else if (oldBalance == 0) {
                store.assets[assetMode][settlor].tokenSet.add(token);
                store.financedTokenSettlors[assetMode][token].add(settlor);
            }
            store.assets[assetMode][settlor].balanceMap[token] = newBalance;
        }
    }

    function _processFinanceSum(
        Store storage store,
        Vars memory varsOld,
        Vars memory varsNew,
        uint256 sumInterestBase,
        address token,
        address _financeContractAddress
    ) internal returns (uint256 gap) {
        if (varsNew.sumRecord != varsOld.sumRecord)
            store.sumFinancedRecordMap[token] = varsNew.sumRecord;
        if (varsNew.sumActual != sumInterestBase)
            store.sumInterestBaseMap[token] = varsNew.sumActual;
        if (store.isTokenFinancingPaused[token]) {
            if (varsNew.sumActual != varsOld.sumActual)
                store.pausingFinancedActualMap[token] = varsNew.sumActual;
        } else if (varsNew.sumActual < varsOld.sumActual) {
            uint256 amount = varsOld.sumActual - varsNew.sumActual;
            gap =
                amount -
                _withdrawFromFinanceContract(
                    token,
                    amount,
                    _financeContractAddress
                );
        } else if (varsNew.sumActual > varsOld.sumActual)
            _depositToFinanceContract(
                token,
                varsNew.sumActual - varsOld.sumActual,
                _financeContractAddress
            );
    }

    function _processFinance(
        Store storage store,
        Vars memory varsOld,
        Vars memory varsNew,
        uint256 sumInterestBase,
        uint256 assetMode,
        address settlor,
        address token,
        address _financeContractAddress
    ) internal returns (uint256 gap) {
        _processFinanceAsset(
            store,
            varsOld.balance,
            varsNew.balance,
            assetMode,
            settlor,
            token
        );
        return
            _processFinanceSum(
                store,
                varsOld,
                varsNew,
                sumInterestBase,
                token,
                _financeContractAddress
            );
    }

    function _collectInterestFee(Store storage store, address[] calldata tokens)
        external
    {
        uint256 _interestFeeRate = store.interestFeeRate;
        address _financeContractAddress = store.financeContractAddress;
        address _receiver1 = store.receiver1;
        address _receiver2 = store.receiver2;
        for (uint256 i = 0; i < tokens.length; i++) {
            (
                uint256 sumFinancedActual,
                uint256 sumInterestBase,
                uint256 fee
            ) = _calculateInterest(
                    store,
                    tokens[i],
                    _financeContractAddress,
                    _interestFeeRate
                );
            if (fee > 0) {
                if (store.isTokenFinancingPaused[tokens[i]])
                    store.pausingFinancedActualMap[tokens[i]] =
                        sumFinancedActual -
                        fee;
                else
                    fee = _withdrawFromFinanceContract(
                        tokens[i],
                        fee,
                        _financeContractAddress
                    );
                if (fee > 0) {
                    store.sumInterestBaseMap[tokens[i]] =
                        sumFinancedActual -
                        fee;
                    _payInterestFee(
                        fee,
                        tokens[i],
                        _receiver1,
                        _receiver2,
                        sumFinancedActual
                    );
                }
            } else if (sumFinancedActual < sumInterestBase)
                store.sumInterestBaseMap[tokens[i]] = sumFinancedActual;
        }
    }

    function _cleanFinancedToken(Store storage store, address[] calldata tokens)
        external
    {
        address _financeContractAddress = store.financeContractAddress;
        for (uint256 i = 0; i < tokens.length; i++)
            if (
                _getFinancedBalance(
                    store,
                    tokens[i],
                    _financeContractAddress
                ) == 0
            ) {
                delete store.sumFinancedRecordMap[tokens[i]];
                delete store.sumInterestBaseMap[tokens[i]];
                for (uint256 assetMode = 0; assetMode < 3; assetMode++) {
                    for (
                        uint256 j = store
                        .financedTokenSettlors[assetMode][tokens[i]].length();
                        j > 0;
                        j--
                    ) {
                        address settlor = store
                        .financedTokenSettlors[assetMode][tokens[i]].at(j - 1);
                        delete store.assets[assetMode][settlor].balanceMap[
                            tokens[i]
                        ];
                        store.assets[assetMode][settlor].tokenSet.remove(
                            tokens[i]
                        );
                        store
                        .financedTokenSettlors[assetMode][tokens[i]].remove(
                                settlor
                            );
                    }
                    if (assetMode < 2)
                        for (
                            uint256 j = store
                            .financedTokenBeneficiaries[assetMode][tokens[i]]
                                .length();
                            j > 0;
                            j--
                        ) {
                            address beneficiary = store
                            .financedTokenBeneficiaries[assetMode][tokens[i]]
                                .at(j - 1);
                            delete store
                            .benefitStatuses[assetMode][beneficiary]
                                .claimableFinancedBalanceMap[tokens[i]];
                            store
                                .benefitStatuses[assetMode][beneficiary]
                                .claimableFinancedTokenSet
                                .remove(tokens[i]);
                            store
                            .financedTokenBeneficiaries[assetMode][tokens[i]]
                                .remove(beneficiary);
                        }
                }
            }
    }

    function _withdraw(
        Store storage store,
        address token,
        uint256 amount,
        uint256 assetMode
    ) external {
        if (!store.isTokenSupported[token]) revert TokenNotSupported();
        if (store.assets[assetMode][msg.sender].isFinanced) {
            address _financeContractAddress = store.financeContractAddress;
            (
                Vars memory varsOld,
                uint256 sumInterestBase,
                uint256 interestFee
            ) = _financeVars(
                    store,
                    assetMode,
                    token,
                    msg.sender,
                    _financeContractAddress,
                    store.interestFeeRate
                );
            uint256 sumActualNew = varsOld.sumActual - interestFee;
            uint256 record = sumInterestBase > 0
                ? (amount * varsOld.sumRecord) / sumActualNew
                : amount;
            if (record > varsOld.balance) record = varsOld.balance;
            amount = record > 0
                ? (record * sumActualNew) / varsOld.sumRecord
                : 0;
            amount -= _processFinance(
                store,
                varsOld,
                Vars(
                    sumActualNew - amount,
                    varsOld.sumRecord - record,
                    varsOld.balance - record
                ),
                sumInterestBase,
                assetMode,
                msg.sender,
                token,
                _financeContractAddress
            );
            uint256 withdrawFee;
            if (amount > 0) {
                withdrawFee = amount / FEE_DIVISOR;
                _transfer(msg.sender, token, amount - withdrawFee);
            }
            if (interestFee + withdrawFee > 0)
                _payInterestFeeAndWithdrawFee(
                    interestFee,
                    withdrawFee,
                    token,
                    store.receiver1,
                    store.receiver2,
                    msg.sender,
                    assetMode,
                    varsOld.sumActual
                );
        } else {
            uint256 balance = store.assets[assetMode][msg.sender].balanceMap[
                token
            ];
            amount = amount < balance ? amount : balance;
            if (amount > 0) {
                store.assets[assetMode][msg.sender].balanceMap[token] =
                    balance -
                    amount;
                if (amount == balance)
                    store.assets[assetMode][msg.sender].tokenSet.remove(token);
                uint256 withdrawFee = amount / FEE_DIVISOR;
                _transfer(msg.sender, token, amount - withdrawFee);
                if (withdrawFee > 0)
                    _payWithdrawFee(
                        withdrawFee,
                        token,
                        store.receiver1,
                        store.receiver2,
                        msg.sender,
                        assetMode
                    );
            }
        }
        emit AssetOperation(
            assetMode,
            msg.sender,
            OperationType.Withdraw,
            token,
            amount,
            block.timestamp
        );
    }

    function _trySetFinancedContractAddress(
        Store storage store,
        address[] storage supportedTokens,
        address newFinanceContractAddress
    ) external {
        address oldFinanceContractAddress = store.financeContractAddress;
        store.financeContractAddress = newFinanceContractAddress;
        uint256 tokenSetLength = supportedTokens.length;
        for (uint256 i = 0; i < tokenSetLength; i++) {
            address token = supportedTokens[i];
            if (
                !store.isTokenFinancingPaused[token] &&
                store.sumFinancedRecordMap[token] > 0
            ) {
                try
                    IFinance(oldFinanceContractAddress).balanceOf(token)
                returns (uint256 balance) {
                    if (balance > 0) {
                        uint256 oldBalance = token == address(0)
                            ? address(this).balance
                            : IERC20(token).balanceOf(address(this));
                        try
                            IFinance(oldFinanceContractAddress).withdraw(
                                token,
                                balance
                            )
                        returns (uint256 amount) {
                            uint256 newBalance = token == address(0)
                                ? address(this).balance
                                : IERC20(token).balanceOf(address(this));
                            if (newBalance > oldBalance && amount > 0) {
                                if (newBalance - oldBalance < amount)
                                    amount = newBalance - oldBalance;
                                _depositToFinanceContract(
                                    token,
                                    amount,
                                    newFinanceContractAddress
                                );
                            }
                        } catch {}
                    }
                } catch {}
            }
        }
    }

    function _pauseTokenFinancing(
        Store storage store,
        address[] calldata tokens
    ) external {
        address _financeContractAddress = store.financeContractAddress;
        for (uint256 i = 0; i < tokens.length; i++) {
            store.isTokenFinancingPaused[tokens[i]] = true;
            if (store.sumFinancedRecordMap[tokens[i]] > 0) {
                uint256 balance = IFinance(_financeContractAddress).balanceOf(
                    tokens[i]
                );
                if (balance > 0) {
                    balance = _withdrawFromFinanceContract(
                        tokens[i],
                        balance,
                        _financeContractAddress
                    );
                    if (balance > 0)
                        store.pausingFinancedActualMap[tokens[i]] = balance;
                }
            }
        }
    }

    function _tryPauseTokenFinancing(
        Store storage store,
        address token,
        uint256 amount
    ) external {
        store.isTokenFinancingPaused[token] = true;
        if (store.sumFinancedRecordMap[token] > 0) {
            address _financeContractAddress = store.financeContractAddress;
            try IFinance(_financeContractAddress).balanceOf(token) returns (
                uint256 balance
            ) {
                if (balance > 0) {
                    uint256 oldBalance = token == address(0)
                        ? address(this).balance
                        : IERC20(token).balanceOf(address(this));
                    try
                        IFinance(_financeContractAddress).withdraw(
                            token,
                            balance
                        )
                    returns (uint256 withdrawAmount) {
                        uint256 newBalance = token == address(0)
                            ? address(this).balance
                            : IERC20(token).balanceOf(address(this));
                        if (newBalance < oldBalance)
                            revert VerificationFailed();
                        if (newBalance - oldBalance < withdrawAmount)
                            withdrawAmount = newBalance - oldBalance;
                        if (withdrawAmount > 0)
                            store.pausingFinancedActualMap[
                                token
                            ] = withdrawAmount;
                    } catch {
                        if (amount > 0) {
                            amount = _withdrawFromFinanceContract(
                                token,
                                amount,
                                _financeContractAddress
                            );
                            if (amount > 0)
                                store.pausingFinancedActualMap[token] = amount;
                        }
                    }
                }
            } catch {
                if (amount > 0) {
                    amount = _withdrawFromFinanceContract(
                        token,
                        amount,
                        _financeContractAddress
                    );
                    if (amount > 0)
                        store.pausingFinancedActualMap[token] = amount;
                }
            }
        }
    }

    function _executeLegacy(Store storage store, address settlor) external {
        delete store.assets[LEGACY][settlor].releaseTime;
        BeneficiaryPercent[]
            memory beneficiaryPercents = new BeneficiaryPercent[](
                store.beneficiaryMaps[LEGACY][settlor].beneficiarySet.length()
            );
        for (uint256 i = 0; i < beneficiaryPercents.length; i++) {
            beneficiaryPercents[i].beneficiary = store
                .beneficiaryMaps[LEGACY][settlor]
                .beneficiarySet
                .at(i);
            beneficiaryPercents[i].percent =
                store.beneficiaryMaps[LEGACY][settlor].percentMap[
                    beneficiaryPercents[i].beneficiary
                ] *
                REMAIN_AFTER_FEE;
            store
                .benefitStatuses[LEGACY][beneficiaryPercents[i].beneficiary]
                .effectiveSettlors
                .remove(settlor);
        }
        if (store.assets[LEGACY][settlor].isFinanced) {
            FinParam memory finParam = FinParam(
                store.interestFeeRate,
                store.financeContractAddress,
                store.receiver1,
                store.receiver2
            );
            for (
                uint256 i = store.assets[LEGACY][settlor].tokenSet.length();
                i > 0;
                i--
            ) {
                TmpVars1 memory _tmp;
                _tmp.token = store.assets[LEGACY][settlor].tokenSet.at(i - 1);
                Vars memory varsOld;
                (
                    varsOld,
                    _tmp.sumInterestBase,
                    _tmp.interestFee
                ) = _financeVars(
                    store,
                    LEGACY,
                    _tmp.token,
                    settlor,
                    finParam.financeContractAddress,
                    finParam.interestFeeRate
                );
                _tmp.feeRecord = varsOld.balance;
                for (uint256 j = 0; j < beneficiaryPercents.length; j++) {
                    uint256 benefitAmount = (varsOld.balance *
                        beneficiaryPercents[j].percent) / PERCENTAGE_SQUARE;
                    if (benefitAmount > 0) {
                        _tmp.feeRecord -= benefitAmount;
                        uint256 claimableBalance = store
                        .benefitStatuses[LEGACY][
                            beneficiaryPercents[j].beneficiary
                        ].claimableFinancedBalanceMap[_tmp.token];
                        if (claimableBalance == 0) {
                            store
                                .benefitStatuses[LEGACY][
                                    beneficiaryPercents[j].beneficiary
                                ]
                                .claimableFinancedTokenSet
                                .add(_tmp.token);
                            store
                            .financedTokenBeneficiaries[LEGACY][_tmp.token].add(
                                    beneficiaryPercents[j].beneficiary
                                );
                        }
                        store
                        .benefitStatuses[LEGACY][
                            beneficiaryPercents[j].beneficiary
                        ].claimableFinancedBalanceMap[_tmp.token] =
                            claimableBalance +
                            benefitAmount;
                    }
                }
                store.assets[LEGACY][settlor].tokenSet.remove(_tmp.token);
                store.financedTokenSettlors[LEGACY][_tmp.token].remove(settlor);
                delete store.assets[LEGACY][settlor].balanceMap[_tmp.token];
                _tmp.withdrawFee =
                    (_tmp.feeRecord * (varsOld.sumActual - _tmp.interestFee)) /
                    varsOld.sumRecord;
                _tmp.withdrawFee -= _processFinanceSum(
                    store,
                    varsOld,
                    Vars(
                        varsOld.sumActual - _tmp.interestFee - _tmp.withdrawFee,
                        varsOld.sumRecord - _tmp.feeRecord,
                        0
                    ),
                    _tmp.sumInterestBase,
                    _tmp.token,
                    finParam.financeContractAddress
                );
                if (_tmp.interestFee + _tmp.withdrawFee > 0)
                    _payInterestFeeAndWithdrawFee(
                        _tmp.interestFee,
                        _tmp.withdrawFee,
                        _tmp.token,
                        finParam.receiver1,
                        finParam.receiver2,
                        settlor,
                        LEGACY,
                        varsOld.sumActual
                    );
                emit AssetOperation(
                    LEGACY,
                    settlor,
                    OperationType.Execute,
                    _tmp.token,
                    (varsOld.balance * (varsOld.sumActual - _tmp.interestFee)) /
                        varsOld.sumRecord,
                    block.timestamp
                );
            }
            delete store.assets[LEGACY][settlor].isFinanced;
            emit FinanceChanged(LEGACY, settlor, false, block.timestamp);
        } else {
            address _receiver1 = store.receiver1;
            address _receiver2 = store.receiver2;
            for (
                uint256 i = store.assets[LEGACY][settlor].tokenSet.length();
                i > 0;
                i--
            ) {
                address token = store.assets[LEGACY][settlor].tokenSet.at(
                    i - 1
                );
                uint256 balance = store.assets[LEGACY][settlor].balanceMap[
                    token
                ];
                uint256 withdrawFee = balance;
                for (uint256 j = 0; j < beneficiaryPercents.length; j++) {
                    uint256 benefitAmount = (balance *
                        beneficiaryPercents[j].percent) / PERCENTAGE_SQUARE;
                    if (benefitAmount > 0) {
                        withdrawFee -= benefitAmount;
                        uint256 claimableBalance = store
                        .benefitStatuses[LEGACY][
                            beneficiaryPercents[j].beneficiary
                        ].claimableBalanceMap[token];
                        if (claimableBalance == 0)
                            store
                                .benefitStatuses[LEGACY][
                                    beneficiaryPercents[j].beneficiary
                                ]
                                .claimableTokenSet
                                .add(token);
                        store
                        .benefitStatuses[LEGACY][
                            beneficiaryPercents[j].beneficiary
                        ].claimableBalanceMap[token] =
                            claimableBalance +
                            benefitAmount;
                    }
                }
                store.assets[LEGACY][settlor].tokenSet.remove(token);
                delete store.assets[LEGACY][settlor].balanceMap[token];
                if (withdrawFee > 0)
                    _payWithdrawFee(
                        withdrawFee,
                        token,
                        _receiver1,
                        _receiver2,
                        settlor,
                        LEGACY
                    );
                emit AssetOperation(
                    LEGACY,
                    settlor,
                    OperationType.Execute,
                    token,
                    balance,
                    block.timestamp
                );
            }
        }
        emit AssetTerminated(LEGACY, settlor, block.timestamp);
    }
}

contract TokenGuard is ReentrancyGuard {
    address private owner;
    address private riskController;
    address[] private supportedTokens = [
        address(0), // ETH
        address(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599), // WBTC
        address(0xdAC17F958D2ee523a2206206994597C13D831ec7), // USDT
        address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) // USDC
    ];
    Store private store;

    constructor(
        address _receiver1,
        address _receiver2,
        address _riskController,
        address _financeContractAddress
    ) {
        store.interestFeeRate = 1e17; // Service fee rate based on financial profit, 1e18 = 100%, initialized to 10%
        store.financeContractAddress = _financeContractAddress;
        store.receiver1 = _receiver1;
        store.receiver2 = _receiver2;
        owner = msg.sender;
        riskController = _riskController;
        uint256 tokenLength = supportedTokens.length;
        for (uint256 i = 0; i < tokenLength; i++)
            store.isTokenSupported[supportedTokens[i]] = true;
        store.isTokenFinancingPaused[
            address(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599)
        ] = true; // WBTC
    }

    function interestFeeRate()
        external
        view
        returns (uint256 _interestFeeRate)
    {
        return store.interestFeeRate;
    }

    function financeContractAddress()
        external
        view
        returns (address _financeContractAddress)
    {
        return store.financeContractAddress;
    }

    function getSupportedTokens()
        external
        view
        returns (address[] memory tokens)
    {
        return supportedTokens;
    }

    function getSupportedTokensAndIsFinancingPaused()
        external
        view
        returns (address[] memory tokens, bool[] memory isFinancingPaused)
    {
        tokens = supportedTokens;
        isFinancingPaused = new bool[](tokens.length);
        for (uint256 i = 0; i < tokens.length; i++)
            isFinancingPaused[i] = store.isTokenFinancingPaused[tokens[i]];
    }

    function getFinancedTokenSettlorsAndBeneficiaries(
        uint256 assetMode,
        address token
    )
        external
        view
        returns (address[] memory settlors, address[] memory beneficiaries)
    {
        return (
            store.financedTokenSettlors[assetMode][token].values(),
            store.financedTokenBeneficiaries[assetMode][token].values()
        );
    }

    function getSumFinancedActualMapAll(bool notQueryFinancedBalance)
        external
        view
        returns (address[] memory tokens, uint256[] memory balances)
    {
        return
            TokenGuardLib._getSumFinancedActualMapAll(
                store,
                supportedTokens,
                notQueryFinancedBalance
            );
    }

    function getFinancedTransform(bool notQueryFinancedBalance)
        external
        view
        returns (
            address[] memory tokens,
            uint256[] memory sumActualBalances,
            uint256[] memory sumRecordBalances,
            uint256[] memory sumInterestBases
        )
    {
        return
            TokenGuardLib._getFinancedTransform(
                store,
                support...

// [truncated — 95566 bytes total]