creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "@openzeppelin/contracts-v4/access/Ownable.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
      },
      "@openzeppelin/contracts-v4/access/Ownable2Step.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n        _transferOwnership(sender);\n    }\n}\n"
      },
      "@openzeppelin/contracts-v4/utils/Context.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
      },
      "@openzeppelin/contracts-v4/utils/structs/EnumerableSet.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)\n// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```solidity\n * contract Example {\n *     // Add the library methods\n *     using EnumerableSet for EnumerableSet.AddressSet;\n *\n *     // Declare a set state variable\n *     EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n *\n * [WARNING]\n * ====\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\n * unusable.\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\n *\n * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an\n * array of EnumerableSet.\n * ====\n */\nlibrary EnumerableSet {\n    // To implement this library for multiple types with as little code\n    // repetition as possible, we write it in terms of a generic Set type with\n    // bytes32 values.\n    // The Set implementation uses private functions, and user-facing\n    // implementations (such as AddressSet) are just wrappers around the\n    // underlying Set.\n    // This means that we can only create new EnumerableSets for types that fit\n    // in bytes32.\n\n    struct Set {\n        // Storage of set values\n        bytes32[] _values;\n        // Position of the value in the `values` array, plus 1 because index 0\n        // means a value is not in the set.\n        mapping(bytes32 => uint256) _indexes;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function _add(Set storage set, bytes32 value) private returns (bool) {\n        if (!_contains(set, value)) {\n            set._values.push(value);\n            // The value is stored at length-1, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            set._indexes[value] = set._values.length;\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function _remove(Set storage set, bytes32 value) private returns (bool) {\n        // We read and store the value's index to prevent multiple reads from the same storage slot\n        uint256 valueIndex = set._indexes[value];\n\n        if (valueIndex != 0) {\n            // Equivalent to contains(set, value)\n            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n            // the array, and then remove the last element (sometimes called as 'swap and pop').\n            // This modifies the order of the array, as noted in {at}.\n\n            uint256 toDeleteIndex = valueIndex - 1;\n            uint256 lastIndex = set._values.length - 1;\n\n            if (lastIndex != toDeleteIndex) {\n                bytes32 lastValue = set._values[lastIndex];\n\n                // Move the last value to the index where the value to delete is\n                set._values[toDeleteIndex] = lastValue;\n                // Update the index for the moved value\n                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex\n            }\n\n            // Delete the slot where the moved value was stored\n            set._values.pop();\n\n            // Delete the index for the deleted slot\n            delete set._indexes[value];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function _contains(Set storage set, bytes32 value) private view returns (bool) {\n        return set._indexes[value] != 0;\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function _length(Set storage set) private view returns (uint256) {\n        return set._values.length;\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function _at(Set storage set, uint256 index) private view returns (bytes32) {\n        return set._values[index];\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function _values(Set storage set) private view returns (bytes32[] memory) {\n        return set._values;\n    }\n\n    // Bytes32Set\n\n    struct Bytes32Set {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _add(set._inner, value);\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _remove(set._inner, value);\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n        return _contains(set._inner, value);\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(Bytes32Set storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n        return _at(set._inner, index);\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\n        bytes32[] memory store = _values(set._inner);\n        bytes32[] memory result;\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n\n    // AddressSet\n\n    struct AddressSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(AddressSet storage set, address value) internal returns (bool) {\n        return _add(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(AddressSet storage set, address value) internal returns (bool) {\n        return _remove(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(AddressSet storage set, address value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(AddressSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(AddressSet storage set, uint256 index) internal view returns (address) {\n        return address(uint160(uint256(_at(set._inner, index))));\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(AddressSet storage set) internal view returns (address[] memory) {\n        bytes32[] memory store = _values(set._inner);\n        address[] memory result;\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n\n    // UintSet\n\n    struct UintSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(UintSet storage set, uint256 value) internal returns (bool) {\n        return _add(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(UintSet storage set, uint256 value) internal returns (bool) {\n        return _remove(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(UintSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n        return uint256(_at(set._inner, index));\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(UintSet storage set) internal view returns (uint256[] memory) {\n        bytes32[] memory store = _values(set._inner);\n        uint256[] memory result;\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n}\n"
      },
      "contracts/f(x)/rebalance-pool/RebalancePoolRegistry.sol": {
        "content": "// SPDX-License-Identifier: MIT\n\npragma solidity =0.8.20;\n\nimport { Ownable2Step } from \"@openzeppelin/contracts-v4/access/Ownable2Step.sol\";\nimport { EnumerableSet } from \"@openzeppelin/contracts-v4/utils/structs/EnumerableSet.sol\";\n\nimport { IFxRebalancePool } from \"../../interfaces/f(x)/IFxRebalancePool.sol\";\nimport { IFxRebalancePoolRegistry } from \"../../interfaces/f(x)/IFxRebalancePoolRegistry.sol\";\n\ncontract RebalancePoolRegistry is Ownable2Step, IFxRebalancePoolRegistry {\n  using EnumerableSet for EnumerableSet.AddressSet;\n\n  /**********\n   * Errors *\n   **********/\n\n  /// @dev Thrown when add an already added pool.\n  error ErrorPoolAlreadyAdded();\n\n  /// @dev Thrown when remove an unkown pool.\n  error ErrorPoolNotAdded();\n\n  /*************\n   * Variables *\n   *************/\n\n  /// @dev The list of registered RebalancePool.\n  EnumerableSet.AddressSet private pools;\n\n  /*************************\n   * Public View Functions *\n   *************************/\n\n  /// @inheritdoc IFxRebalancePoolRegistry\n  function getPools() external view override returns (address[] memory _pools) {\n    uint256 _length = pools.length();\n    _pools = new address[](_length);\n    for (uint256 i = 0; i < _length; i++) {\n      _pools[i] = pools.at(i);\n    }\n  }\n\n  /// @inheritdoc IFxRebalancePoolRegistry\n  function totalSupply() external view override returns (uint256) {\n    uint256 _length = pools.length();\n    uint256 _totalSupply;\n    for (uint256 i = 0; i < _length; i++) {\n      address _pool = pools.at(i);\n      _totalSupply += IFxRebalancePool(_pool).totalSupply();\n    }\n    return _totalSupply;\n  }\n\n  /************************\n   * Restricted Functions *\n   ************************/\n\n  /// @notice Add a RebalancePool to the list.\n  /// @param _pool The address of RebalancePool to add.\n  function registerRebalancePool(address _pool) external onlyOwner {\n    if (!pools.add(_pool)) revert ErrorPoolAlreadyAdded();\n\n    emit RegisterPool(_pool);\n  }\n\n  /// @notice Remove an exsiting RebalancePool.\n  /// @param _pool The address of RebalancePool to remove.\n  function deregisterRebalancePool(address _pool) external onlyOwner {\n    if (!pools.remove(_pool)) revert ErrorPoolNotAdded();\n\n    emit DeregisterPool(_pool);\n  }\n}\n"
      },
      "contracts/interfaces/f(x)/IFxRebalancePool.sol": {
        "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0 || ^0.8.0;\n\ninterface IFxRebalancePool {\n  /**********\n   * Events *\n   **********/\n\n  /// @notice Emitted when user deposit asset into this contract.\n  /// @param owner The address of asset owner.\n  /// @param reciever The address of recipient of the asset in this contract.\n  /// @param amount The amount of asset deposited.\n  event Deposit(address indexed owner, address indexed reciever, uint256 amount);\n\n  /// @notice Emitted when the amount of deposited asset changed due to liquidation or deposit or unlock.\n  /// @param owner The address of asset owner.\n  /// @param newDeposit The new amount of deposited asset.\n  /// @param loss The amount of asset used by liquidation.\n  event UserDepositChange(address indexed owner, uint256 newDeposit, uint256 loss);\n\n  /// @notice Emitted when the amount of unlocking asset changed due to liquidation or unlock or withdraw.\n  /// @param owner The address of asset owner.\n  /// @param newUnlock The new amount of unlocking asset.\n  /// @param loss The amount of asset used by liquidation.\n  event UserUnlockChange(address indexed owner, uint256 newUnlock, uint256 loss);\n\n  /// @notice Emitted when user unlock part of its deposition.\n  /// @param amount The amount of token to unlock.\n  /// @param unlockAt The timestamp in second when the asset will be unlocked.\n  event Unlock(address indexed owner, uint256 amount, uint256 unlockAt);\n\n  /// @notice Emitted when user withdraw unlocked asset.\n  /// @param owner The address of asset owner.\n  /// @param amount The amount of token to withdraw.\n  event WithdrawUnlocked(address indexed owner, uint256 amount);\n\n  /// @notice Emitted when new rewards are deposited to this contract.\n  /// @param token The address of the token.\n  /// @param amount The amount of token deposited.\n  event DepositReward(address indexed token, uint256 amount);\n\n  /// @notice Emitted when user claim pending reward token.\n  /// @param owner The address of asset owner.\n  /// @param token The address of token.\n  /// @param amount The amount of pending reward claimed.\n  event Claim(address indexed owner, address indexed token, uint256 amount);\n\n  /// @notice Emitted when liquidation happens.\n  /// @param liquidated The amount of asset liquidated.\n  /// @param baseGained The amount of base token gained.\n  event Liquidate(uint256 liquidated, uint256 baseGained);\n\n  /*************************\n   * Public View Functions *\n   *************************/\n\n  /// @notice Return the address of underlying token of this contract.\n  function asset() external view returns (address);\n\n  /// @notice Return the total amount of asset deposited to this contract.\n  function totalSupply() external view returns (uint256);\n\n  /// @notice Return the amount of deposited asset for some specific user.\n  /// @param account The address of user to query.\n  function balanceOf(address account) external view returns (uint256);\n\n  /// @notice Return the amount of unlocked asset for some specific user.\n  /// @param account The address of user to query.\n  function unlockedBalanceOf(address account) external view returns (uint256);\n\n  /// @notice Return the amount of unlocking asset for some specific user.\n  /// @param account The address of user to query.\n  /// @return balance The amount of unlocking asset.\n  /// @return unlockAt The timestamp in second when the asset is unlocked.\n  function unlockingBalanceOf(address account) external view returns (uint256 balance, uint256 unlockAt);\n\n  /// @notice Return the amount of reward token can be claimed.\n  /// @param account The address of user to query.\n  /// @param token The address of reward token to query.\n  function claimable(address account, address token) external view returns (uint256);\n\n  /****************************\n   * Public Mutated Functions *\n   ****************************/\n\n  /// @notice Deposit some asset to this contract.\n  /// @dev Use `amount=uint256(-1)` if you want to deposit all asset held.\n  /// @param amount The amount of asset to deposit.\n  /// @param recipient The address of receiver for the deposited asset.\n  function deposit(uint256 amount, address recipient) external;\n\n  /// @notice Unlock some deposited asset.\n  /// @dev If the amount if larger than current deposited asset, all asset will be used.\n  /// @param amount The amount of asset to unlock.\n  function unlock(uint256 amount) external;\n\n  /// @notice Withdraw unlocked asset from this contract.\n  /// @param _claim Whether the user want to claim pending rewards.\n  /// @param unwrap Whether the user want to unwrap autocompounding rewards.\n  function withdrawUnlocked(bool _claim, bool unwrap) external;\n\n  /// @notice Claim pending reward from this contract.\n  /// @param token The address of token to claim.\n  /// @param unwrap Whether the user want to unwrap autocompounding rewards.\n  function claim(address token, bool unwrap) external;\n\n  /// @notice Claim multiple pending rewards from this contract.\n  /// @param tokens The list of reward tokens to claim.\n  /// @param unwrap Whether the user want to unwrap autocompounding rewards.\n  function claim(address[] memory tokens, bool unwrap) external;\n\n  /// @notice Liquidate asset for base token.\n  /// @param maxAmount The maximum amount of asset to liquidate.\n  /// @param minBaseOut The minimum amount of base token should receive.\n  /// @return liquidated The amount of asset liquidated.\n  /// @return baseOut The amount of base token received.\n  function liquidate(uint256 maxAmount, uint256 minBaseOut) external returns (uint256 liquidated, uint256 baseOut);\n\n  /// @notice Update the snapshot for some specific user.\n  /// @param account The address of user to update.\n  function updateAccountSnapshot(address account) external;\n\n  /// @notice Deposit some reward token to this contract.\n  /// @param token The address of token to deposit.\n  /// @param amount The amount of token to deposit.\n  function depositReward(address token, uint256 amount) external;\n}\n"
      },
      "contracts/interfaces/f(x)/IFxRebalancePoolRegistry.sol": {
        "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0 || ^0.8.0;\n\ninterface IFxRebalancePoolRegistry {\n  /**********\n   * Events *\n   **********/\n\n  /// @notice Emitted when a new rebalance pool is added.\n  /// @param pool The address of the rebalance pool.\n  event RegisterPool(address indexed pool);\n\n  /// @notice Emitted when an exsited rebalance pool is removed.\n  /// @param pool The address of the rebalance pool.\n  event DeregisterPool(address indexed pool);\n\n  /*************************\n   * Public View Functions *\n   *************************/\n\n  /// @notice Return the address list of all registered RebalancePool.\n  function getPools() external view returns (address[] memory pools);\n\n  /// @notice Return the total amount of asset managed by all registered RebalancePool.\n  function totalSupply() external view returns (uint256);\n}\n"
      }
    },
    "settings": {
      "optimizer": {
        "enabled": true,
        "runs": 200
      },
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}