{"file_path":"src/USG/Utilities/MarketCreator.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\n/**\n _____\n/  __ \\\n| /  \\/ ___  _ ____   _____ _ __ __ _  ___ _ __   ___ ___\n| |    / _ \\| '_ \\ \\ / / _ \\ '__/ _` |/ _ \\ '_ \\ / __/ _ \\\n| \\__/\\ (_) | | | \\ V /  __/ | | (_| |  __/ | | | (_|  __/\n \\____/\\___/|_| |_|\\_/ \\___|_|  \\__, |\\___|_| |_|\\___\\___|\n                                 __/ |\n                                |___/\n */\npragma solidity ^0.8.0;\n\nimport {LightOwnable} from \"../Utilities/abstract/LightOwnable.sol\";\nimport {Clones} from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\nimport {GlobalMarketInitParams, MarketInit, IRewardAccumulator, IERC20Metadata, IERC20} from \"../../interfaces/internals/USG/IMarketCore.sol\";\nimport {IConvexCrvLPMarket, ICvxRewardToken} from \"../../interfaces/internals/USG/IConvexCrvLPMarket.sol\";\nimport {ICurveGaugeMarket, IGauge} from \"../../interfaces/internals/USG/ICurveGaugeMarket.sol\";\nimport {IStakeDaoVaultV2Market, IStakeDaoVaultV2} from \"../../interfaces/internals/USG/IStakeDaoVaultV2Market.sol\";\nimport {IConvexFxnLPMarket} from \"../../interfaces/internals/USG/IConvexFxnLPMarket.sol\";\nimport {IBasicERC20Market} from \"../../interfaces/internals/USG/IBasicERC20Market.sol\";\nimport {IControlTower} from \"../../interfaces/internals/USG/IControlTower.sol\";\nimport {IRParams, IIRCalculator} from \"../../interfaces/internals/USG/IIRCalculator.sol\";\nimport {RCParams} from \"../../interfaces/internals/USG/IRewardAccumulator.sol\";\nimport {IZappingProxy} from \"../../interfaces/internals/USG/IZappingProxy.sol\";\nimport {IUSG} from \"../../interfaces/internals/USG/IUSG.sol\";\n\n/// @title  MarketCreator\n/// @author Tangent Finance\n/// @notice Factory to deploy market following the Minimal proxy implementation\ncontract MarketCreator is LightOwnable {\n    using Clones for address;\n\n    /// @notice Control tower\n    IControlTower public controlTower;\n\n    /// @notice USG token\n    IUSG public USG;\n\n    /// @notice IR Calculator\n    IIRCalculator public irCalculator;\n\n    /// @notice Reward accumulator\n    IRewardAccumulator public rewardAccumulator;\n\n    /// @notice Zapping proxy\n    IZappingProxy public zappingProxy;\n\n    /// @notice Convex CRV market implementation\n    address public marketConvexCrv;\n\n    /// @notice Convex FXN market implementation\n    address public marketConvexFxn;\n\n    /// @notice Market Curve gauge implementation\n    address public marketCurveGauge;\n\n    /// @notice Market Curve gauge implementation\n    address public marketStakeDaoVaultV2;\n\n    /// @notice Basic ERC20 market implementation\n    address public marketBasicERC20;\n\n    event MarketConvexCrvCreated(address proxy, string name);\n    event MarketConvexFxnCreated(address proxy, string name);\n    event MarketCurveGaugeCreated(address proxy, string name);\n    event MarketStakeDaoVaultV2Created(address proxy, string name);\n    event BasicERC20MarketCreated(address proxy, string name);\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                            CONSTRUCTOR\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    constructor(\n        address _owner,\n        IControlTower _controlTower,\n        IUSG _USG,\n        IIRCalculator _irCalculator,\n        IRewardAccumulator _rewardAccumulator,\n        IZappingProxy _zappingProxy,\n        address _marketConvexCrv,\n        address _marketConvexFxn,\n        address _marketCurveGauge,\n        address _marketStakeDaoVaultV2,\n        address _marketBasicERC20\n    ) {\n        controlTower = _controlTower;\n        USG = _USG;\n        irCalculator = _irCalculator;\n        rewardAccumulator = _rewardAccumulator;\n        zappingProxy = _zappingProxy;\n        marketConvexCrv = _marketConvexCrv;\n        marketConvexFxn = _marketConvexFxn;\n        marketCurveGauge = _marketCurveGauge;\n        marketStakeDaoVaultV2 = _marketStakeDaoVaultV2;\n        marketBasicERC20 = _marketBasicERC20;\n        _transferOwnership(_owner);\n    }\n\n    function _getGlobalParams() internal view returns (GlobalMarketInitParams memory) {\n        return\n            GlobalMarketInitParams({\n                _owner: owner,\n                _USG: USG,\n                _controlTower: controlTower,\n                _irCalculator: irCalculator,\n                _rewardAccumulator: rewardAccumulator,\n                _zappingProxy: zappingProxy\n            });\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of Curve Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexCrvMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexCrv.clone();\n        IConvexCrvLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexCrvCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a FXN Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of FXN Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexFxnMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexFxn.clone();\n        IConvexFxnLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexFxnCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createCurveGaugeMarket(MarketInit calldata _marketInit, IGauge _gauge, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketCurveGauge.clone();\n        ICurveGaugeMarket(proxy).initialize(_getGlobalParams(), _marketInit, _gauge);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketCurveGaugeCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createStakeDaoVaultV2Market(\n        MarketInit calldata _marketInit,\n        IStakeDaoVaultV2 _vault,\n        IRParams calldata _irParams,\n        RCParams calldata _rcParams\n    ) external onlyOwner returns (address) {\n        address proxy = marketStakeDaoVaultV2.clone();\n        IStakeDaoVaultV2Market(proxy).initialize(_getGlobalParams(), _marketInit, _vault);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketStakeDaoVaultV2Created(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createBasicERC20Market(MarketInit calldata _marketInit, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketBasicERC20.clone();\n        IBasicERC20Market(proxy).initialize(_getGlobalParams(), _marketInit);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit BasicERC20MarketCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    function _commonInitialize(address newProxy, IRParams calldata _irParams, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) internal {\n        // Set market as minter and burner of USG\n        USG.initializeMarket(newProxy);\n        // Set up IRParams and initialize debt index for the market\n        irCalculator.initializeMarket(newProxy, _irParams);\n        // Set up RewardCut params and initialize debt index for the market\n        rewardAccumulator.initializeMarket(newProxy, rewardTokens, _rcParams);\n    }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"cancun","libraries":{},"optimizer":{"enabled":true,"runs":1000000},"outputSelection":{"*":{"":["*"],"*":["*"]}}},"optimization_runs":1000000,"sourcify_repo_url":null,"decoded_constructor_args":[["0x461B62CB3A7e9Df8f800aE058AE92F855F2c27Ca",{"internalType":"address","name":"_owner","type":"address"}],["0xF3f7669dcEED2f985815011C19eD68F667267215",{"internalType":"contract IControlTower","name":"_controlTower","type":"address"}],["0xB1c2Db5d6cA03FCe73dBd304d320bF76C55Ae1B1",{"internalType":"contract IUSG","name":"_USG","type":"address"}],["0xB4e1d3bBd2843263d58B4D648C599512cea6e88b",{"internalType":"contract IIRCalculator","name":"_irCalculator","type":"address"}],["0xB91FEA3834417d9Dfe581262b20E86F5bDfEC9FA",{"internalType":"contract IRewardAccumulator","name":"_rewardAccumulator","type":"address"}],["0xA9E0021d8917C51F496823605d218d7E78719c99",{"internalType":"contract IZappingProxy","name":"_zappingProxy","type":"address"}],["0x68e75bFC46FE4cD2eaa1cEB1fD68990916A0ebfB",{"internalType":"address","name":"_marketConvexCrv","type":"address"}],["0xA6C6193aBAf2F1b72ED251984D391eaAc7c31e77",{"internalType":"address","name":"_marketConvexFxn","type":"address"}],["0xD7A63E1fFfF888488DB275189078282DA8a4e638",{"internalType":"address","name":"_marketCurveGauge","type":"address"}],["0xBCE94d131b288590F1ef1f62622865bA1fa514e4",{"internalType":"address","name":"_marketStakeDaoVaultV2","type":"address"}],["0xb10Ec742bc530B4FD5484F6364993d9bD98642b8",{"internalType":"address","name":"_marketBasicERC20","type":"address"}]],"compiler_version":"v0.8.28+commit.7893614a","is_verified_via_verifier_alliance":false,"verified_at":"2026-06-16T05:53:02.404764Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"MarketCreator","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"cancun","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts/interfaces/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},{"file_path":"@openzeppelin/contracts/proxy/Clones.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (proxy/Clones.sol)\n\npragma solidity ^0.8.20;\n\nimport {Create2} from \"../utils/Create2.sol\";\nimport {Errors} from \"../utils/Errors.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n */\nlibrary Clones {\n    error CloneArgumentsTooLong();\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function clone(address implementation) internal returns (address instance) {\n        return clone(implementation, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency\n     * to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function clone(address implementation, uint256 value) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create(value, 0x09, 0x37)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy\n     * the clone. Using the same `implementation` and `salt` multiple times will revert, since\n     * the clones cannot be deployed twice at the same address.\n     */\n    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n        return cloneDeterministic(implementation, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with\n     * a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministic(\n        address implementation,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create2(value, 0x09, 0x37, salt)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(add(ptr, 0x38), deployer)\n            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)\n            mstore(add(ptr, 0x14), implementation)\n            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)\n            mstore(add(ptr, 0x58), salt)\n            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))\n            predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddress(implementation, salt, address(this));\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function cloneWithImmutableArgs(address implementation, bytes memory args) internal returns (address instance) {\n        return cloneWithImmutableArgs(implementation, args, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneWithImmutableArgs-address-bytes-}[cloneWithImmutableArgs], but with a `value`\n     * parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        assembly (\"memory-safe\") {\n            instance := create(value, add(bytecode, 0x20), mload(bytecode))\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same\n     * `implementation`, `args` and `salt` multiple times will revert, since the clones cannot be deployed twice\n     * at the same address.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        return cloneDeterministicWithImmutableArgs(implementation, args, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-}[cloneDeterministicWithImmutableArgs],\n     * but with a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.deploy(value, salt, bytecode);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.computeAddress(salt, keccak256(bytecode), deployer);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddressWithImmutableArgs(implementation, args, salt, address(this));\n    }\n\n    /**\n     * @dev Get the immutable args attached to a clone.\n     *\n     * - If `instance` is a clone that was deployed using `clone` or `cloneDeterministic`, this\n     *   function will return an empty array.\n     * - If `instance` is a clone that was deployed using `cloneWithImmutableArgs` or\n     *   `cloneDeterministicWithImmutableArgs`, this function will return the args array used at\n     *   creation.\n     * - If `instance` is NOT a clone deployed using this library, the behavior is undefined. This\n     *   function should only be used to check addresses that are known to be clones.\n     */\n    function fetchCloneArgs(address instance) internal view returns (bytes memory) {\n        bytes memory result = new bytes(instance.code.length - 45); // revert if length is too short\n        assembly (\"memory-safe\") {\n            extcodecopy(instance, add(result, 32), 45, mload(result))\n        }\n        return result;\n    }\n\n    /**\n     * @dev Helper that prepares the initcode of the proxy with immutable args.\n     *\n     * An assembly variant of this function requires copying the `args` array, which can be efficiently done using\n     * `mcopy`. Unfortunately, that opcode is not available before cancun. A pure solidity implementation using\n     * abi.encodePacked is more expensive but also more portable and easier to review.\n     *\n     * NOTE: https://eips.ethereum.org/EIPS/eip-170[EIP-170] limits the length of the contract code to 24576 bytes.\n     * With the proxy code taking 45 bytes, that limits the length of the immutable args to 24531 bytes.\n     */\n    function _cloneCodeWithImmutableArgs(\n        address implementation,\n        bytes memory args\n    ) private pure returns (bytes memory) {\n        if (args.length > 24531) revert CloneArgumentsTooLong();\n        return\n            abi.encodePacked(\n                hex\"61\",\n                uint16(args.length + 45),\n                hex\"3d81600a3d39f3363d3d373d3d3d363d73\",\n                implementation,\n                hex\"5af43d82803e903d91602b57fd5bf3\",\n                args\n            );\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},{"file_path":"src/interfaces/externals/Curve/IGauge.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IGauge is IERC20Metadata {\n    function initialize(address _lp_token) external;\n    function integrate_checkpoint() external view returns (uint256);\n    function user_checkpoint(address addr) external returns (bool);\n    function claimable_tokens(address addr) external returns (uint256);\n    function claimed_reward(address _addr, address _token) external view returns (uint256);\n    function claimable_reward(address _user, address _reward_token) external view returns (uint256);\n    function set_rewards_receiver(address _receiver) external;\n    function claim_rewards() external;\n    function claim_rewards(address _addr) external;\n    function claim_rewards(address _addr, address _receiver) external;\n    function kick(address addr) external;\n    function deposit(uint256 _value) external;\n    function deposit(uint256 _value, address _addr) external;\n    function deposit(uint256 _value, address _addr, bool _claim_rewards) external;\n    function withdraw(uint256 _value) external;\n    function withdraw(uint256 _value, bool _claim_rewards) external;\n    function transfer(address _to, uint256 _value) external returns (bool);\n    function transferFrom(address _from, address _to, uint256 _value) external returns (bool);\n    function approve(address _spender, uint256 _value) external returns (bool);\n    function increaseAllowance(address _spender, uint256 _added_value) external returns (bool);\n    function decreaseAllowance(address _spender, uint256 _subtracted_value) external returns (bool);\n    function add_reward(address _reward_token, address _distributor) external;\n    function set_reward_distributor(address _reward_token, address _distributor) external;\n    function deposit_reward_token(address _reward_token, uint256 _amount) external;\n    function set_killed(bool _is_killed) external;\n    function lp_token() external view returns (address);\n    function future_epoch_time() external view returns (uint256);\n    function balanceOf(address arg0) external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function allowance(address arg0, address arg1) external view returns (uint256);\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function working_balances(address arg0) external view returns (uint256);\n    function working_supply() external view returns (uint256);\n    function period() external view returns (int128);\n    function period_timestamp(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply_of(address arg0) external view returns (uint256);\n    function integrate_checkpoint_of(address arg0) external view returns (uint256);\n    function integrate_fraction(address arg0) external view returns (uint256);\n    function inflation_rate() external view returns (uint256);\n    function reward_count() external view returns (uint256);\n    function reward_tokens(uint256 arg0) external view returns (address);\n    function reward_data(address arg0) external view returns (address token, address distributor, uint256 period_finish, uint256 rate, uint256 last_update, uint256 integral);\n    function rewards_receiver(address arg0) external view returns (address);\n    function reward_integral_for(address arg0, address arg1) external view returns (uint256);\n    function is_killed() external view returns (bool);\n    function factory() external view returns (address);\n    function staking_token() external view returns (address);\n}\n"},{"file_path":"src/interfaces/internals/USG/IIRCalculator.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nstruct IRParams {\n    /// @dev Flag to determine if a Market is HEC or LEC\n    bool isHEC;\n    /// @dev Minimum IR reached at pMax.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint24 rMin;\n    /// @dev Maximum IR reached at pMin.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint32 rMax;\n    /// @dev Minimum price of USG where rMax is reached.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMin;\n    /// @dev Inflexion price of USG where IR starts to increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pInf;\n    /// @dev Maximum price of USG where IR increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMax;\n    /// @dev Convexity of the curve before pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a1;\n    /// @dev Convexity of the curve after pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a2;\n    /// @dev Velocity of the transition between a1 and a2\n    ///      It's an integer. 250 <=> 250\n    uint32 k;\n}\n\nstruct IRCheckpoint {\n    uint216 ir;\n    uint40 timestamp;\n}\ninterface IIRCalculator {\n    function initializeMarket(address market, IRParams calldata _irParam) external;\n\n    function simulateIR(uint256 USGPrice, IRParams memory irParam) external view returns (uint256);\n\n    function computeIRForMarket(address market) external returns (uint256);\n\n    function checkpointIR(address market) external returns (uint256);\n\n    function newDebtIndex(address market) external view returns (uint256);\n\n    function irCheckpoints(address market) external view returns (uint216, uint40);\n\n    function debtIndexes(address market) external view returns (uint256);\n\n    function indexDelta(address market) external view returns (uint256);\n\n    function mintableInterests() external view returns (uint256);\n\n    function getIRParams(address market) external view returns (IRParams memory);\n\n    function getIRCheckpoint(address market) external view returns (IRCheckpoint memory);\n}\n"},{"file_path":"src/interfaces/internals/USG/IMarketCore.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\nimport {IUSG} from \"./IUSG.sol\";\nimport {ICollateral, IERC20Metadata} from \"./ICollateral.sol\";\nimport {IControlTower} from \"./IControlTower.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\nimport {IZappingProxy} from \"./IZappingProxy.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nstruct LiquidationPre {\n    uint256 newDebtIndex;\n    uint256 collatBalance;\n    uint256 _userDebtShares;\n    uint256 userDebt_;\n}\n\nstruct LiquidateIn {\n    address account;\n    PostLiquidate postLiquidate;\n    uint256 minCollatValueToLiquidate;\n}\n\nstruct LiquidateTransitionStruct {\n    LiquidateIn liquidateIn;\n    uint256 collatPrice;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct PostLiquidate {\n    uint256 collatAmountToLiquidate;\n    uint256 minUsgOut;\n    uint256 maxUsgToBurn;\n    uint256 minCollatAmountToLiquidate;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateIn {\n    uint256 collatAmountToLiquidate;\n    uint256 usgToRepay;\n    uint256 maxUsgToBurn;\n    uint256 minUsgOut;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateTransitionStruct {\n    SelfLiquidateIn selfLiquidateIn;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct LeverageIn {\n    uint256 collatToDeposit;\n    uint256 usgToFlashMint;\n    uint256 minCollatAmountOut;\n    bool isReceiptIn;\n}\n\nstruct GlobalMarketInitParams {\n    address _owner;\n    IUSG _USG;\n    IControlTower _controlTower;\n    IIRCalculator _irCalculator;\n    IRewardAccumulator _rewardAccumulator;\n    IZappingProxy _zappingProxy;\n}\n\nstruct MarketInit {\n    IERC20Metadata collatToken;\n    IPriceOracle collatOracle;\n    uint256 maxLTV;\n    uint256 liquidationThreshold;\n    uint256 liquidationFee;\n    uint256 maxMarketDebt;\n    uint256 minimumLoan;\n    IERC20[] rewardTokens;\n    string name;\n}\n"},{"file_path":"src/interfaces/internals/USG/IPriceOracle.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\ninterface IPriceOracle {\n    function latestAnswer(bool isNoFailMode) external view returns (uint256);\n\n    function latestAnswerUpdate(bool isNoFailMode) external returns (uint256);\n\n    function decimals() external view returns (uint8);\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Create2.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Create2.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n    /**\n     * @dev There's no code to deploy.\n     */\n    error Create2EmptyBytecode();\n\n    /**\n     * @dev Deploys a contract using `CREATE2`. The address where the contract\n     * will be deployed can be known in advance via {computeAddress}.\n     *\n     * The bytecode for a contract can be obtained from Solidity with\n     * `type(contractName).creationCode`.\n     *\n     * Requirements:\n     *\n     * - `bytecode` must not be empty.\n     * - `salt` must have not been used for `bytecode` already.\n     * - the factory must have a balance of at least `amount`.\n     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n     */\n    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n        if (bytecode.length == 0) {\n            revert Create2EmptyBytecode();\n        }\n        assembly (\"memory-safe\") {\n            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n            // if no address was created, and returndata is not empty, bubble revert\n            if and(iszero(addr), not(iszero(returndatasize()))) {\n                let p := mload(0x40)\n                returndatacopy(p, 0, returndatasize())\n                revert(p, returndatasize())\n            }\n        }\n        if (addr == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n     * `bytecodeHash` or `salt` will result in a new destination address.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n        return computeAddress(salt, bytecodeHash, address(this));\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40) // Get free memory pointer\n\n            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |\n            // | salt              |                                      BBBBBBBBBBBBB...BB                   |\n            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |\n            // | 0xFF              |            FF                                                             |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |\n            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |\n\n            mstore(add(ptr, 0x40), bytecodeHash)\n            mstore(add(ptr, 0x20), salt)\n            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes\n            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff\n            mstore8(start, 0xff)\n            addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Errors.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},{"file_path":"src/USG/Utilities/abstract/LightOwnable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nabstract contract LightOwnable {\n    address public owner;\n\n    error OwnableUnauthorizedAccount(address account);\n\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\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 Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner != msg.sender) {\n            revert OwnableUnauthorizedAccount(msg.sender);\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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"},{"file_path":"src/interfaces/externals/Convex/ICvxRewardToken.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface ICvxRewardToken is IERC20 {\n    function addExtraReward(address _reward) external returns (bool);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function clearExtraRewards() external;\n\n    function currentRewards() external view returns (uint256);\n\n    function donate(uint256 _amount) external returns (bool);\n\n    function duration() external view returns (uint256);\n\n    function earned(address account) external view returns (uint256);\n\n    function extraRewards(uint256) external view returns (address);\n\n    function extraRewardsLength() external view returns (uint256);\n\n    function getReward() external returns (bool);\n\n    function getReward(address _account, bool _claimExtras) external returns (bool);\n\n    function historicalRewards() external view returns (uint256);\n\n    function lastTimeRewardApplicable() external view returns (uint256);\n\n    function lastUpdateTime() external view returns (uint256);\n\n    function newRewardRatio() external view returns (uint256);\n\n    function operator() external view returns (address);\n\n    function periodFinish() external view returns (uint256);\n\n    function pid() external view returns (uint256);\n\n    function queueNewRewards(uint256 _rewards) external returns (bool);\n\n    function queuedRewards() external view returns (uint256);\n\n    function rewardManager() external view returns (address);\n\n    function rewardPerToken() external view returns (uint256);\n\n    function rewardPerTokenStored() external view returns (uint256);\n\n    function rewardRate() external view returns (uint256);\n\n    function rewardToken() external view returns (address);\n\n    function rewards(address) external view returns (uint256);\n\n    function stake(uint256 _amount) external returns (bool);\n\n    function stakeAll() external returns (bool);\n\n    function stakeFor(address _for, uint256 _amount) external returns (bool);\n\n    function stakingToken() external view returns (IERC20Metadata);\n\n    function totalSupply() external view returns (uint256);\n\n    function userRewardPerTokenPaid(address) external view returns (uint256);\n\n    function withdraw(uint256 amount, bool claim) external returns (bool);\n\n    function withdrawAll(bool claim) external;\n\n    function withdrawAllAndUnwrap(bool claim) external;\n\n    function withdrawAndUnwrap(uint256 amount, bool claim) external returns (bool);\n}\n"},{"file_path":"src/interfaces/externals/Convex/IStakingProxyERC20.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport \"../FXN/ISharedLiquidityGauge.sol\";\ninterface IStakingProxyERC20 {\n    function FEE_DENOMINATOR() external view returns (uint256);\n    function deposit(uint256 _amount, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function earned() external returns (address[] memory token_addresses, uint256[] memory total_earned);\n    function execute(address _to, uint256 _value, bytes memory _data) external returns (bool, bytes memory);\n    function feeRegistry() external view returns (address);\n    function fxn() external view returns (address);\n    function fxnMinter() external view returns (address);\n    function gaugeAddress() external view returns (ISharedLiquidityGauge);\n    function getReward() external;\n    function getReward(bool _claim, address[] memory _tokenList) external;\n    function getReward(bool _claim) external;\n    function initialize(address _owner, uint256 _pid) external;\n    function owner() external view returns (address);\n    function pid() external view returns (uint256);\n    function poolRegistry() external view returns (address);\n    function rewards() external view returns (address);\n    function setVeFXNProxy(address _proxy) external;\n    function stakingToken() external view returns (address);\n    function transferTokens(address[] memory _tokenList) external;\n    function usingProxy() external view returns (address);\n    function vaultType() external pure returns (uint8);\n    function vaultVersion() external pure returns (uint256);\n    function vefxnProxy() external view returns (address);\n    function withdraw(uint256 _amount) external;\n}\n"},{"file_path":"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\ninterface ISharedLiquidityGauge {\n    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n    function REWARD_MANAGER_ROLE() external view returns (bytes32);\n    function acceptSharedVote(address _newOwner) external;\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address _account) external;\n    function claim(address _account) external;\n    function claim(address _account, address _receiver) external;\n    function claim() external;\n    function claimHistorical(address[] memory _tokens) external;\n    function claimHistorical(address _account, address[] memory _tokens) external;\n    function claimable(address _account, address _token) external view returns (uint256);\n    function claimed(address _account, address _token) external view returns (uint256);\n    function controller() external view returns (address);\n    function decimals() external view returns (uint8);\n    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);\n    function deposit(uint256 _amount, address _receiver) external;\n    function deposit(uint256 _amount, address _receiver, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function depositReward(address _token, uint256 _amount) external;\n    function disableGauge() external;\n    function distributors(address) external view returns (address);\n    function eip712Domain()\n        external\n        view\n        returns (bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions);\n    function getActiveRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getHistoricalRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n    function getStakerVoteOwner(address _account) external view returns (address);\n    function governanceToken() external view returns (address);\n    function grantRole(bytes32 role, address account) external;\n    function hasRole(bytes32 role, address account) external view returns (bool);\n    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);\n    function inflationParams() external view returns (uint192 rate, uint64 futureEpochTime);\n    function initialize(address _stakingToken) external;\n    function integrate_fraction(address account) external view returns (uint256);\n    function isActive() external view returns (bool);\n    function isStakerAllowed(address, address) external view returns (bool);\n    function kick(address _account) external;\n    function manager() external view returns (address);\n    function minter() external view returns (address);\n    function name() external view returns (string memory);\n    function nonces(address owner) external view returns (uint256);\n    function numAcceptedStakers(address) external view returns (uint256);\n    function pendingRewards(address _token) external view returns (uint256, uint256);\n    function periodLength() external view returns (uint40);\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;\n    function registerRewardToken(address _token, address _distributor) external;\n    function rejectSharedVote() external;\n    function renounceRole(bytes32 role, address account) external;\n    function revokeRole(bytes32 role, address account) external;\n    function rewardData(address) external view returns (uint96 queued, uint80 rate, uint40 lastUpdate, uint40 finishAt);\n    function rewardReceiver(address) external view returns (address);\n    function rewardSnapshot(address) external view returns (uint64 timestamp, uint192 integral);\n    function setRewardReceiver(address _newReceiver) external;\n    function sharedBalanceOf(address) external view returns (uint256);\n    function snapshot() external view returns (uint64 timestamp, uint192 integral);\n    function stakingToken() external view returns (address);\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n    function symbol() external view returns (string memory);\n    function toggleVoteSharing(address _staker) external;\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 amount) external returns (bool);\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n    function unregisterRewardToken(address _token) external;\n    function updateLiquidityManager(address _newManager) external;\n    function updateRewardDistributor(address _token, address _newDistributor) external;\n    function user_checkpoint(address _account) external returns (bool);\n    function ve() external view returns (address);\n    function veProxy() external view returns (address);\n    function withdraw(uint256 _amount, address _receiver) external;\n    function withdraw(uint256 _amount) external;\n    function workingBalanceOf(address) external view returns (uint256);\n    function workingSupply() external view returns (uint256);\n}\n"},{"file_path":"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport {IERC20Metadata, IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IStakeDaoVaultV2 is IERC20Metadata {\n    function ACCOUNTANT() external view returns (address);\n    function DEFAULT_REWARDS_DURATION() external view returns (uint32);\n    function POLICY() external view returns (uint8);\n    function PROTOCOL_CONTROLLER() external view returns (address);\n    function PROTOCOL_ID() external view returns (bytes4);\n    function accountData(address account, address rewardToken) external view returns (uint128 rewardPerTokenPaid, uint128 claimable);\n    function addRewardToken(address rewardToken, address distributor) external;\n    function allocator() external view returns (address _allocator);\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 value) external returns (bool);\n    function asset() external view returns (address);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address account) external;\n    function claim(address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function claim(address account, address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function convertToAssets(uint256 shares) external pure returns (uint256);\n    function convertToShares(uint256 assets) external pure returns (uint256);\n    function decimals() external view returns (uint8);\n    function deposit(uint256 assets, address receiver, address referrer) external returns (uint256);\n    function deposit(address account, address receiver, uint256 assets, address referrer) external returns (uint256);\n    function deposit(uint256 assets, address receiver) external returns (uint256);\n    function depositRewards(address rewardToken, uint128 amount) external;\n    function earned(address account, address token) external view returns (uint128);\n    function gauge() external view returns (address _gauge);\n    function getClaimable(address token, address account) external view returns (uint128);\n    function getLastUpdateTime(address token) external view returns (uint32);\n    function getPeriodFinish(address token) external view returns (uint32);\n    function getRewardPerTokenPaid(address token, address account) external view returns (uint128);\n    function getRewardPerTokenStored(address token) external view returns (uint128);\n    function getRewardRate(address token) external view returns (uint128);\n    function getRewardTokens() external view returns (address[] memory);\n    function getRewardsDistributor(address token) external view returns (address);\n    function isRewardToken(address rewardToken) external view returns (bool);\n    function lastTimeRewardApplicable(address token) external view returns (uint256);\n    function maxDeposit(address) external pure returns (uint256);\n    function maxMint(address _account) external pure returns (uint256);\n    function maxRedeem(address owner) external view returns (uint256);\n    function maxWithdraw(address owner) external view returns (uint256);\n    function mint(uint256 shares, address receiver) external returns (uint256);\n    function mint(uint256 shares, address receiver, address referrer) external returns (uint256);\n    function name() external view returns (string memory);\n    function previewDeposit(uint256 shares) external pure returns (uint256);\n    function previewMint(uint256 assets) external pure returns (uint256);\n    function previewRedeem(uint256 shares) external pure returns (uint256);\n    function previewWithdraw(uint256 assets) external pure returns (uint256);\n    function redeem(uint256 shares, address receiver, address owner) external returns (uint256);\n    function resumeVault() external;\n    function rewardData(\n        address rewardToken\n    ) external view returns (address rewardsDistributor, uint32 lastUpdateTime, uint32 periodFinish, uint128 rewardRate, uint128 rewardPerTokenStored);\n    function rewardPerToken(address token) external view returns (uint128);\n    function strategy() external view returns (address _strategy);\n    function symbol() external view returns (string memory);\n    function totalAssets() external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 value) external returns (bool);\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256);\n}\n"},{"file_path":"src/interfaces/internals/ICommonStruct.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nstruct TokenAmount {\n    IERC20 token;\n    uint256 amount;\n}\nstruct ZapStruct {\n    address router;\n    bytes routerCall;\n}\nstruct ZapStructDeposit {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    uint256 minAmountOut;\n    ZapStruct zap;\n}\n\nstruct ZapStructDepositNoMinAmount {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    ZapStruct zap;\n}\n"},{"file_path":"src/interfaces/internals/USG/IBasicERC20Market.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\ninterface IBasicERC20Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit) external;\n}\n"},{"file_path":"src/interfaces/internals/USG/ICollateral.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\n\ninterface ICollateral {\n    function collatOracle() external view returns (IPriceOracle);\n\n    function collatToken() external view returns (IERC20Metadata);\n\n    function collatDecimals() external view returns (uint256);\n\n    function collateralBalances(address account) external view returns (uint256);\n\n    function totalCollateral() external view returns (uint256);\n\n    function maxLTV() external view returns (uint256);\n\n    function liquidationThreshold() external view returns (uint256);\n\n    function rewardAccumulator() external view returns (IRewardAccumulator);\n\n    function getBalanceAndTotalCollateral(address account) external view returns (uint256, uint256);\n}\n"},{"file_path":"src/interfaces/internals/USG/IControlTower.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\n\ninterface IControlTower {\n    function isMarketCreator(address marketCreator) external view returns (bool);\n\n    function isPositionMigrator(address migrator) external view returns (bool);\n\n    function isPauser(address pauser) external view returns (bool);\n\n    function feeTreasury() external view returns (address);\n}\n"},{"file_path":"src/interfaces/internals/USG/IConvexCrvLPMarket.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {ICvxRewardToken} from \"../../externals/Convex/ICvxRewardToken.sol\";\ninterface IConvexCrvLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function cvxRewardToken() external view returns (ICvxRewardToken);\n}\n"},{"file_path":"src/interfaces/internals/USG/IConvexFxnLPMarket.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakingProxyERC20} from \"../../externals/Convex/IStakingProxyERC20.sol\";\ninterface IConvexFxnLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function stakingProxyVault() external view returns (IStakingProxyERC20);\n}\n"},{"file_path":"src/interfaces/internals/USG/ICurveGaugeMarket.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IGauge} from \"../../externals/Curve/IGauge.sol\";\ninterface ICurveGaugeMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IGauge _gauge) external;\n}\n"},{"file_path":"src/interfaces/internals/USG/IDebtIR.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\n\ninterface IDebtIR {\n    function maxMarketDebt() external view returns (uint256);\n    function irCalculator() external view returns (IIRCalculator);\n    function minimumLoan() external view returns (uint256);\n    function userDebtShares(address user) external view returns (uint256);\n    function totalDebtShares() external view returns (uint256);\n    function badDebt() external view returns (uint256);\n}\n"},{"file_path":"src/interfaces/internals/USG/IRewardAccumulator.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {TokenAmount, IERC20} from \"../ICommonStruct.sol\";\n\nstruct Reward {\n    uint128 lastUpdateTime;\n    uint128 periodFinish;\n    uint256 rewardRate;\n    uint256 rewardPerTokenStored;\n}\nstruct RCParams {\n    uint16 harvestFeePercentage;\n    /// @dev Amount of distincts reward cut steps.\n    uint16 stepAmount;\n    /// @dev Percentage minimum of the reward cut.\n    uint32 startCutPercentage;\n    /// @dev Percentage maximum of the reward cut.\n    uint32 endCutPercentage;\n    /// @dev Price of USG on which the reward cut starts to increase.\n    uint80 startCutPrice;\n    /// @dev Price of USG on which the reward cut is at its maximum\n    uint80 endCutPrice;\n}\ninterface IRewardAccumulator {\n    function cutFeeForToken(IERC20 token) external view returns (uint256);\n\n    function getRewardData(address market, IERC20 token) external view returns (Reward memory);\n\n    function updateRewards(address account, uint256 collateralBalances, uint256 totalCollateral) external;\n\n    function processRewards(address market, address harvestFeeReceiver) external;\n\n    function getRewardTokens(address markets) external view returns (IERC20[] memory);\n\n    function lastRewardCuts(address market) external view returns (uint256);\n\n    function claimableRewards(address market, address _account) external view returns (TokenAmount[] memory userRewards);\n\n    function simulateRC(uint256 USGPrice, RCParams calldata rcParams) external pure returns (uint256);\n\n    function computeRCForMarket(address market) external returns (uint256);\n\n    function initializeMarket(address market, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) external;\n\n    function getRCParams(address markets) external view returns (RCParams memory);\n}\n"},{"file_path":"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakeDaoVaultV2} from \"../../externals/StakeDao/IStakeDaoVaultV2.sol\";\ninterface IStakeDaoVaultV2Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IStakeDaoVaultV2 _vault) external;\n}\n"},{"file_path":"src/interfaces/internals/USG/IUSG.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\ninterface IUSG is IERC20 {\n    function mintDebt(address to, uint256 amount) external;\n\n    function burnDebt(address from, uint256 amount) external;\n\n    function mintIR(uint256 amount) external;\n\n    function initializeMarket(address market) external;\n}\n"},{"file_path":"src/interfaces/internals/USG/IZappingProxy.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\n\ninterface IZappingProxy {\n    function zapProxy(IERC20 tokenIn, IERC20 tokenOut, uint256 minAmountOut, address receiver, ZapStruct calldata routerCall) external payable returns (uint256);\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"contract IControlTower","name":"_controlTower","type":"address"},{"internalType":"contract IUSG","name":"_USG","type":"address"},{"internalType":"contract IIRCalculator","name":"_irCalculator","type":"address"},{"internalType":"contract IRewardAccumulator","name":"_rewardAccumulator","type":"address"},{"internalType":"contract IZappingProxy","name":"_zappingProxy","type":"address"},{"internalType":"address","name":"_marketConvexCrv","type":"address"},{"internalType":"address","name":"_marketConvexFxn","type":"address"},{"internalType":"address","name":"_marketCurveGauge","type":"address"},{"internalType":"address","name":"_marketStakeDaoVaultV2","type":"address"},{"internalType":"address","name":"_marketBasicERC20","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FailedDeployment","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"BasicERC20MarketCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketConvexCrvCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketConvexFxnCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketCurveGaugeCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketStakeDaoVaultV2Created","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"},{"inputs":[],"name":"USG","outputs":[{"internalType":"contract IUSG","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controlTower","outputs":[{"internalType":"contract IControlTower","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createBasicERC20Market","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createConvexCrvMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createConvexFxnMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"contract IGauge","name":"_gauge","type":"address"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createCurveGaugeMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"contract IStakeDaoVaultV2","name":"_vault","type":"address"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createStakeDaoVaultV2Market","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"irCalculator","outputs":[{"internalType":"contract IIRCalculator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketBasicERC20","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConvexCrv","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConvexFxn","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketCurveGauge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketStakeDaoVaultV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardAccumulator","outputs":[{"internalType":"contract IRewardAccumulator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"zappingProxy","outputs":[{"internalType":"contract IZappingProxy","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"000000000000000000000000461b62cb3a7e9df8f800ae058ae92f855f2c27ca000000000000000000000000f3f7669dceed2f985815011c19ed68f667267215000000000000000000000000b1c2db5d6ca03fce73dbd304d320bf76c55ae1b1000000000000000000000000b4e1d3bbd2843263d58b4d648c599512cea6e88b000000000000000000000000b91fea3834417d9dfe581262b20e86f5bdfec9fa000000000000000000000000a9e0021d8917c51f496823605d218d7e78719c9900000000000000000000000068e75bfc46fe4cd2eaa1ceb1fd68990916a0ebfb000000000000000000000000a6c6193abaf2f1b72ed251984d391eaac7c31e77000000000000000000000000d7a63e1ffff888488db275189078282da8a4e638000000000000000000000000bce94d131b288590f1ef1f62622865ba1fa514e4000000000000000000000000b10ec742bc530b4fd5484f6364993d9bd98642b8"}