Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPoolDeposit2, Contribution} from "./IPoolDeposit2.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

contract PoolDepositU is IPoolDeposit2, UUPSUpgradeable, OwnableUpgradeable {
    uint256 constant MAX_CONTRIBUTIONS = 100;
    uint256 constant MIN_REFUND = 1e15;
    string constant DEPOSIT_PREFIX = "d_";
    string constant CONTRACT_SUFFIX = "_rbxp";
    address public timelock;
    address public rabbit;
    address public defaultToken;
    mapping(address => bool) public supportedTokens;
    mapping(address => uint256) public minDeposits;

    uint256 nextDepositNum;
    uint256 nextPoolId;

    event Withdrawal(address indexed to, uint256 amount, address indexed token);
    event SetRabbit(address indexed rabbit);
    event SupportToken(address indexed token, uint256 minDeposit);
    event UnsupportToken(address indexed token);

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    function initialize(
        address _timelock,
        address _owner,
        address _rabbit,
        address _defaultToken,
        uint256 _minDeposit,
        address[] memory _otherTokens,
        uint256[] memory _minDeposits
    ) public initializer {
        __Ownable_init(_owner);
        __UUPSUpgradeable_init();

        timelock = _timelock;
        rabbit = _rabbit;
        defaultToken = _defaultToken;
        supportedTokens[_defaultToken] = true;
        minDeposits[_defaultToken] = _minDeposit;
        for (uint256 i = 0; i < _otherTokens.length; i++) {
            address token = _otherTokens[i];
            supportedTokens[token] = true;
            minDeposits[token] = _minDeposits[i];
        }
        nextDepositNum = 1;
        nextPoolId = 10000;
    }

    modifier onlyTimelock() {
        require(msg.sender == timelock, "ONLY_TIMELOCK");
        _;
    }

    function _authorizeUpgrade(address newImplementation) internal override onlyTimelock {
    }

    function supportToken(
        address _token,
        uint256 _minDeposit
    ) external onlyOwner {
        supportedTokens[_token] = true;
        minDeposits[_token] = _minDeposit;
        emit SupportToken(_token, _minDeposit);
    }

    function unsupportToken(address _token) external onlyOwner {
        supportedTokens[_token] = false;
        emit UnsupportToken(_token);
    }

    function allocateDepositId() private returns (string memory depositId) {
        uint256 depositNum = nextDepositNum;
        nextDepositNum++;
        return string(
            abi.encodePacked(
                DEPOSIT_PREFIX,
                Strings.toString(depositNum),
                CONTRACT_SUFFIX
            )
        );
    }

    function allocatePoolId() private returns (uint256) {
        uint256 poolId = nextPoolId;
        nextPoolId++;
        return poolId;
    }

    function individualDeposit(address contributor, uint256 amount) external {
        require(amount >= minDeposits[defaultToken], "AMOUNT_TOO_SMALL");
        string memory depositId = allocateDepositId();
        emit Deposit(depositId, contributor, amount, defaultToken, 0);
        bool success = makeTransferFrom(
            msg.sender,
            rabbit,
            amount,
            defaultToken
        );
        require(success, "TRANSFER_FAILED");
    }

    function depositToken(
        address contributor,
        uint256 amount,
        address token
    ) external {
        require(supportedTokens[token], "UNSUPPORTED_TOKEN");
        require(amount >= minDeposits[token], "AMOUNT_TOO_SMALL");
        string memory depositId = allocateDepositId();
        emit Deposit(depositId, contributor, amount, token, 0);
        uint256 prevBalance = IERC20(token).balanceOf(rabbit);
        bool success = makeTransferFrom(
            msg.sender,
            rabbit,
            amount,
            token
        );
        require(success, "TRANSFER_FAILED");
        uint256 newBalance = IERC20(token).balanceOf(rabbit);
        require(newBalance == amount + prevBalance, "NOT_ENOUGH_TRANSFERRED");
    }

    function depositNative(address contributor) external payable {
        address native = address(0);
        require(supportedTokens[native], "UNSUPPORTED_TOKEN");
        uint256 minDeposit = minDeposits[native];
        require(msg.value >= minDeposit, "AMOUNT_TOO_SMALL");
        string memory depositId = allocateDepositId();
        emit Deposit(depositId, contributor, msg.value, native, 0);
        (bool success, ) = rabbit.call{value: msg.value}("");
        require(success, "TRANSFER_FAILED");
    }

    function pooledDeposit(Contribution[] calldata contributions) external {
        uint256 totalAmount = pooledDepositCommon(contributions, defaultToken);
        bool success = makeTransferFrom(
            msg.sender,
            rabbit,
            totalAmount,
            defaultToken
        );
        require(success, "TRANSFER_FAILED");
    }

    function pooledDepositNative(
        Contribution[] calldata contributions
    ) external payable {
        uint256 totalAmount = pooledDepositCommon(contributions, address(0));
        require(msg.value >= totalAmount, "VALUE_TOO_SMALL");
        if (msg.value - totalAmount >= MIN_REFUND) {
            (bool success, ) = msg.sender.call{
                value: msg.value - totalAmount
            }("");
            require(success, "REFUND_FAILED");
        } 
    }

    function pooledDepositToken(
        Contribution[] calldata contributions,
        address token
    ) public {
        uint256 totalAmount = pooledDepositCommon(contributions, token);
        bool success = makeTransferFrom(
            msg.sender,
            rabbit,
            totalAmount,
            token
        );
        require(success, "TRANSFER_FAILED");
    }

    function pooledDepositCommon(
        Contribution[] calldata contributions,
        address token
    ) private returns (uint256 totalAmount) {
        require(supportedTokens[token], "UNSUPPORTED_TOKEN");
        uint256 poolId = allocatePoolId();
        totalAmount = 0;
        if (contributions.length > MAX_CONTRIBUTIONS) {
            revert("TOO_MANY_CONTRIBUTIONS");
        }
        for (uint i = 0; i < contributions.length; i++) {
            Contribution calldata contribution = contributions[i];
            uint256 contribAmount = contribution.amount;
            totalAmount += contribAmount;
            require(contribAmount >= minDeposits[token], "WRONG_AMOUNT");
            require(totalAmount >= contribAmount, "INTEGRITY_OVERFLOW_ERROR");
            string memory depositId = allocateDepositId();
            emit Deposit(
                depositId,
                contribution.contributor,
                contribAmount,
                token,
                poolId
            );
        }
        require(totalAmount > 0, "WRONG_AMOUNT");
        emit PooledDeposit(poolId, totalAmount, token);
        return totalAmount;
    }

    // There is no reason for the contract to hold any tokens as its only
    // purpose is to transfer tokens to the RabbitX contract and have credit
    // for them awarded on the exchange.
    // The following function allows recovery of tokens in the event that
    // any are mistakenly sent to this contract.
    // Without it any tokens transferred to the contract would be effectively
    // burned, as there would be no way to retrieve them.
    function withdrawTokensTo(
        address to,
        uint256 amount,
        address token
    ) external onlyOwner {
        require(amount > 0, "WRONG_AMOUNT");
        require(to != address(0), "ZERO_TO_ADDRESS");
        bool success = makeTransfer(to, amount, token);
        require(success, "TRANSFER_FAILED");
        emit Withdrawal(to, amount, token);
    }

    function withdrawNativeTo(address to, uint256 amount) external onlyOwner {
        require(amount > 0, "WRONG_AMOUNT");
        require(to != address(0), "ZERO_TO_ADDRESS");
        (bool success, ) = to.call{value: amount}("");
        require(success, "TRANSFER_FAILED");
        emit Withdrawal(to, amount, address(0));
    }

    function setRabbit(address _rabbit) external onlyTimelock {
        rabbit = _rabbit;
        emit SetRabbit(_rabbit);
    }

    function transferOwnership(address newOwner) public virtual override onlyTimelock {
        require(newOwner != address(0), "ZERO_OWNER");
        _transferOwnership(newOwner);
    }

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

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

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

    function getVersion() public pure returns (uint256) {
        return 21;
    }
}

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

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

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

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;

    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
        assembly {
            $.slot := OwnableStorageLocation
        }
    }

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

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

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    function __Ownable_init(address initialOwner) internal onlyInitializing {
        __Ownable_init_unchained(initialOwner);
    }

    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.20;

import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol";
import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
import {Initializable} from "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable __self = address(this);

    /**
     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`
     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,
     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.
     * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must
     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function
     * during an upgrade.
     */
    string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";

    /**
     * @dev The call is from an unauthorized context.
     */
    error UUPSUnauthorizedCallContext();

    /**
     * @dev The storage `slot` is unsupported as a UUID.
     */
    error UUPSUnsupportedProxiableUUID(bytes32 slot);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        _checkProxy();
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        _checkNotDelegated();
        _;
    }

    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual notDelegated returns (bytes32) {
        return ERC1967Utils.IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data);
    }

    /**
     * @dev Reverts if the execution is not performed via delegatecall or the execution
     * context is not of a proxy with an ERC1967-compliant implementation pointing to self.
     * See {_onlyProxy}.
     */
    function _checkProxy() internal view virtual {
        if (
            address(this) == __self || // Must be called through delegatecall
            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy
        ) {
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Reverts if the execution is performed via delegatecall.
     * See {notDelegated}.
     */
    function _checkNotDelegated() internal view virtual {
        if (address(this) != __self) {
            // Must not be called through delegatecall
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.
     *
     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value
     * is expected to be the implementation slot in ERC1967.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
                revert UUPSUnsupportedProxiableUUID(slot);
            }
            ERC1967Utils.upgradeToAndCall(newImplementation, data);
        } catch {
            // The implementation is not UUPS
            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
        }
    }
}

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

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

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

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

pragma solidity ^0.8.20;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {UpgradeableBeacon} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)

pragma solidity ^0.8.20;

import {IBeacon} from "../beacon/IBeacon.sol";
import {Address} from "../../utils/Address.sol";
import {StorageSlot} from "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 */
library ERC1967Utils {
    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.
    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev The `implementation` of the proxy is invalid.
     */
    error ERC1967InvalidImplementation(address implementation);

    /**
     * @dev The `admin` of the proxy is invalid.
     */
    error ERC1967InvalidAdmin(address admin);

    /**
     * @dev The `beacon` of the proxy is invalid.
     */
    error ERC1967InvalidBeacon(address beacon);

    /**
     * @dev An upgrade function sees `msg.value > 0` that may be lost.
     */
    error ERC1967NonPayable();

    /**
     * @dev Returns the current implementation address.
     */
    function getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        if (newImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(newImplementation);
        }
        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Performs implementation upgrade with additional setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);

        if (data.length > 0) {
            Address.functionDelegateCall(newImplementation, data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using
     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    function getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        if (newAdmin == address(0)) {
            revert ERC1967InvalidAdmin(address(0));
        }
        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {IERC1967-AdminChanged} event.
     */
    function changeAdmin(address newAdmin) internal {
        emit AdminChanged(getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        if (newBeacon.code.length == 0) {
            revert ERC1967InvalidBeacon(newBeacon);
        }

        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;

        address beaconImplementation = IBeacon(newBeacon).implementation();
        if (beaconImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(beaconImplementation);
        }
    }

    /**
     * @dev Change the beacon and trigger a setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-BeaconUpgraded} event.
     *
     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
     * efficiency.
     */
    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);

        if (data.length > 0) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
     * if an upgrade doesn't perform an initialization call.
     */
    function _checkNonPayable() private {
        if (msg.value > 0) {
            revert ERC1967NonPayable();
        }
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 256, 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @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), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @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) {
        uint256 localValue = value;
        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] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

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

struct Contribution {
    address contributor;
    uint256 amount;
} 

interface IPoolDeposit2 {

    event Deposit(string id, address indexed trader, uint256 amount, address indexed token, uint256 indexed poolId);
    event PooledDeposit(uint256 indexed id, uint256 amount, address indexed token);
    
    function individualDeposit(address contributor, uint256 amount) external;
    function pooledDeposit(Contribution[] calldata contributions) external;
    function depositToken(
        address contributor,
        uint256 amount,
        address token
    ) external;
    function pooledDepositToken(
        Contribution[] calldata contributions,
        address token
    ) external;
    function depositNative(address contributor) external payable;
    function pooledDepositNative(
        Contribution[] calldata contributions
    ) external payable;
}

{
  "viaIR": true,
  "optimizer": {
    "enabled": true,
    "runs": 200,
    "details": {
      "yulDetails": {
        "optimizerSteps": "u"
      }
    }
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"id","type":"string"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"poolId","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"PooledDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rabbit","type":"address"}],"name":"SetRabbit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"minDeposit","type":"uint256"}],"name":"SupportToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"UnsupportToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"Withdrawal","type":"event"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"contributor","type":"address"}],"name":"depositNative","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"contributor","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getVersion","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"contributor","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"individualDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_timelock","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_rabbit","type":"address"},{"internalType":"address","name":"_defaultToken","type":"address"},{"internalType":"uint256","name":"_minDeposit","type":"uint256"},{"internalType":"address[]","name":"_otherTokens","type":"address[]"},{"internalType":"uint256[]","name":"_minDeposits","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"contributor","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Contribution[]","name":"contributions","type":"tuple[]"}],"name":"pooledDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"contributor","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Contribution[]","name":"contributions","type":"tuple[]"}],"name":"pooledDepositNative","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"contributor","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Contribution[]","name":"contributions","type":"tuple[]"},{"internalType":"address","name":"token","type":"address"}],"name":"pooledDepositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rabbit","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rabbit","type":"address"}],"name":"setRabbit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_minDeposit","type":"uint256"}],"name":"supportToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"supportedTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"unsupportToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawNativeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"withdrawTokensTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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