{"compiler":{"version":"0.8.23+commit.f704f362"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_treasury","type":"address"},{"internalType":"address","name":"_marketConfigurator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CallerNotApprovedLiquidatorException","type":"error"},{"inputs":[],"name":"CallerNotTreasuryException","type":"error"},{"inputs":[],"name":"ForceApproveFailed","type":"error"},{"inputs":[],"name":"IncorrectWrappedUnderlyingException","type":"error"},{"inputs":[],"name":"InsufficientTreasuryFundsException","type":"error"},{"inputs":[],"name":"InvalidCreditSuiteException","type":"error"},{"inputs":[],"name":"SafeTransferFromFailed","type":"error"},{"inputs":[],"name":"UnsupportedTokenPairException","type":"error"},{"inputs":[],"name":"ZeroAddressException","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"creditFacade","type":"address"},{"indexed":true,"internalType":"address","name":"creditAccount","type":"address"},{"indexed":true,"internalType":"address","name":"liquidator","type":"address"}],"name":"PartiallyLiquidateFromTreasury","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SetLiquidatorStatus","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"assetIn","type":"address"},{"indexed":true,"internalType":"address","name":"assetOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"rate","type":"uint256"}],"name":"SetMinExchangeRate","type":"event"},{"inputs":[],"name":"contractType","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"liquidator","type":"address"}],"name":"isLiquidator","outputs":[{"internalType":"bool","name":"isAllowed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConfigurator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetIn","type":"address"},{"internalType":"address","name":"assetOut","type":"address"}],"name":"minExchangeRates","outputs":[{"internalType":"uint256","name":"rate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"creditFacade","type":"address"},{"internalType":"address","name":"creditAccount","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"repaidAmount","type":"uint256"},{"components":[{"internalType":"address","name":"priceFeed","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct PriceUpdate[]","name":"priceUpdates","type":"tuple[]"},{"internalType":"address","name":"wrappedUnderlying","type":"address"}],"name":"partiallyLiquidateFromTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setLiquidatorStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetIn","type":"address"},{"internalType":"address","name":"assetOut","type":"address"},{"internalType":"uint256","name":"rate","type":"uint256"}],"name":"setMinExchangeRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"kind":"dev","methods":{"constructor":{"params":{"_marketConfigurator":"The address of the market configurator","_treasury":"The address of the treasury"}},"partiallyLiquidateFromTreasury(address,address,address,uint256,(address,bytes)[],address)":{"params":{"creditAccount":"The credit account to partially liquidate","creditFacade":"The credit facade contract","priceUpdates":"Optional price updates to apply before liquidation","repaidAmount":"The amount of underlying to repay","token":"The collateral token to seize","wrappedUnderlying":"ERC4626 vault that wraps the underlying token, if unwrapping is required"}},"setLiquidatorStatus(address,bool)":{"params":{"liquidator":"The address to set status for","status":"True to approve, false to revoke"}},"setMinExchangeRate(address,address,uint256)":{"params":{"assetIn":"The asset being provided for liquidation","assetOut":"The asset expected to be received from liquidation","rate":"The minimum exchange rate (RATE_PRECISION format)"}}},"title":"TreasuryLiquidator","version":1},"userdoc":{"errors":{"ZeroAddressException()":[{"notice":"Thrown on attempting to set an important address to zero address"}]},"kind":"user","methods":{"constructor":{"notice":"Constructor"},"contractType()":{"notice":"Contract type for identification"},"isLiquidator(address)":{"notice":"Mapping of approved liquidators who can use this contract"},"marketConfigurator()":{"notice":"The market configurator address"},"minExchangeRates(address,address)":{"notice":"Mapping of minimum exchange rates (assetIn => assetOut => rate) Rate is in PERCENTAGE_FACTOR format (i.e. 10050 means 1.005 units of collateral per unit of underlying, regardless of decimals)"},"partiallyLiquidateFromTreasury(address,address,address,uint256,(address,bytes)[],address)":{"notice":"Partially liquidate a credit account using funds from the treasury"},"setLiquidatorStatus(address,bool)":{"notice":"Set liquidator status"},"setMinExchangeRate(address,address,uint256)":{"notice":"Set minimum exchange rate between two assets"},"treasury()":{"notice":"The treasury address that funds are taken from and returned to"},"version()":{"notice":"Contract version"}},"notice":"This contract allows the treasury to liquidate credit accounts by providing the funds needed for liquidation and receiving the seized collateral. The treasury can set exchange rates for different token pairs, as well as approve liquidators to use this contract.","version":1}},"settings":{"compilationTarget":{"contracts/emergency/TreasuryLiquidator.sol":"TreasuryLiquidator"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"none","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1000},"remappings":[":@1inch/=lib/@1inch/",":@gearbox-protocol/=lib/@gearbox-protocol/",":@openzeppelin/=lib/@openzeppelin/",":@redstone-finance/=node_modules/@redstone-finance/",":@solady/=lib/@solady/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/@openzeppelin/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin/=lib/@openzeppelin/contracts/"]},"sources":{"contracts/emergency/TreasuryLiquidator.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IERC4626} from \"@openzeppelin/contracts/interfaces/IERC4626.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport {SafeERC20} from \"@1inch/solidity-utils/contracts/libraries/SafeERC20.sol\";\n\nimport {ICreditManagerV3} from \"@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol\";\nimport {ICreditFacadeV3} from \"@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol\";\nimport {PriceUpdate} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IPriceFeedStore.sol\";\nimport {SanityCheckTrait} from \"@gearbox-protocol/core-v3/contracts/traits/SanityCheckTrait.sol\";\nimport {PERCENTAGE_FACTOR} from \"@gearbox-protocol/core-v3/contracts/libraries/Constants.sol\";\n\nimport {IMarketConfigurator} from \"@gearbox-protocol/permissionless/contracts/interfaces/IMarketConfigurator.sol\";\nimport {IContractsRegister} from \"@gearbox-protocol/permissionless/contracts/interfaces/IContractsRegister.sol\";\n\n/**\n * @title TreasuryLiquidator\n * @notice This contract allows the treasury to liquidate credit accounts by providing the funds\n * needed for liquidation and receiving the seized collateral. The treasury can set exchange rates\n * for different token pairs, as well as approve liquidators to use this contract.\n */\ncontract TreasuryLiquidator is SanityCheckTrait {\n using SafeERC20 for IERC20;\n\n /// @notice Contract type for identification\n bytes32 public constant contractType = \"TREASURY_LIQUIDATOR\";\n\n /// @notice Contract version\n uint256 public constant version = 3_10;\n\n /// @notice The treasury address that funds are taken from and returned to\n address public immutable treasury;\n\n /// @notice The market configurator address\n address public immutable marketConfigurator;\n\n /// @notice Mapping of approved liquidators who can use this contract\n mapping(address liquidator => bool isAllowed) public isLiquidator;\n\n /// @notice Mapping of minimum exchange rates (assetIn => assetOut => rate)\n /// Rate is in PERCENTAGE_FACTOR format (i.e. 10050 means 1.005 units of collateral per unit of underlying, regardless of decimals)\n mapping(address assetIn => mapping(address assetOut => uint256 rate)) public minExchangeRates;\n\n // EVENTS\n event PartiallyLiquidateFromTreasury(\n address indexed creditFacade, address indexed creditAccount, address indexed liquidator\n );\n event SetLiquidatorStatus(address indexed liquidator, bool status);\n event SetMinExchangeRate(address indexed assetIn, address indexed assetOut, uint256 rate);\n\n // ERRORS\n error CallerNotTreasuryException();\n error CallerNotApprovedLiquidatorException();\n error InsufficientTreasuryFundsException();\n error UnsupportedTokenPairException();\n error InvalidCreditSuiteException();\n error IncorrectWrappedUnderlyingException();\n\n /// @notice Modifier to verify the sender is the treasury\n modifier onlyTreasury() {\n if (msg.sender != treasury) revert CallerNotTreasuryException();\n _;\n }\n\n /// @notice Modifier to verify the sender is an approved liquidator\n modifier onlyLiquidator() {\n if (!isLiquidator[msg.sender]) revert CallerNotApprovedLiquidatorException();\n _;\n }\n\n /// @notice Modifier to verify the credit facade is from the market configurator\n /// @param creditFacade The credit facade address\n modifier onlyCFFromMarketConfigurator(address creditFacade) {\n address creditManager = ICreditFacadeV3(creditFacade).creditManager();\n bool isValidCM = IContractsRegister(IMarketConfigurator(marketConfigurator).contractsRegister()).isCreditManager(\n creditManager\n );\n if (!isValidCM || ICreditManagerV3(creditManager).creditFacade() != creditFacade) {\n revert InvalidCreditSuiteException();\n }\n _;\n }\n\n /**\n * @notice Constructor\n * @param _treasury The address of the treasury\n * @param _marketConfigurator The address of the market configurator\n */\n constructor(address _treasury, address _marketConfigurator)\n nonZeroAddress(_treasury)\n nonZeroAddress(_marketConfigurator)\n {\n treasury = _treasury;\n marketConfigurator = _marketConfigurator;\n }\n\n /**\n * @notice Set liquidator status\n * @param liquidator The address to set status for\n * @param status True to approve, false to revoke\n */\n function setLiquidatorStatus(address liquidator, bool status) external onlyTreasury nonZeroAddress(liquidator) {\n if (isLiquidator[liquidator] == status) return;\n isLiquidator[liquidator] = status;\n emit SetLiquidatorStatus(liquidator, status);\n }\n\n /**\n * @notice Set minimum exchange rate between two assets\n * @param assetIn The asset being provided for liquidation\n * @param assetOut The asset expected to be received from liquidation\n * @param rate The minimum exchange rate (RATE_PRECISION format)\n */\n function setMinExchangeRate(address assetIn, address assetOut, uint256 rate)\n external\n onlyTreasury\n nonZeroAddress(assetIn)\n nonZeroAddress(assetOut)\n {\n if (minExchangeRates[assetIn][assetOut] == rate) return;\n\n minExchangeRates[assetIn][assetOut] = rate;\n emit SetMinExchangeRate(assetIn, assetOut, rate);\n }\n\n /**\n * @notice Partially liquidate a credit account using funds from the treasury\n * @param creditFacade The credit facade contract\n * @param creditAccount The credit account to partially liquidate\n * @param token The collateral token to seize\n * @param repaidAmount The amount of underlying to repay\n * @param priceUpdates Optional price updates to apply before liquidation\n * @param wrappedUnderlying ERC4626 vault that wraps the underlying token, if unwrapping is required\n */\n function partiallyLiquidateFromTreasury(\n address creditFacade,\n address creditAccount,\n address token,\n uint256 repaidAmount,\n PriceUpdate[] calldata priceUpdates,\n address wrappedUnderlying\n ) external onlyLiquidator onlyCFFromMarketConfigurator(creditFacade) {\n address underlying = ICreditFacadeV3(creditFacade).underlying();\n\n uint256 minSeizedAmount = _getMinSeizedAmount(underlying, token, repaidAmount);\n\n _transferUnderlying(underlying, wrappedUnderlying, repaidAmount);\n {\n address creditManager = ICreditFacadeV3(creditFacade).creditManager();\n IERC20(underlying).forceApprove(creditManager, repaidAmount);\n }\n\n ICreditFacadeV3(creditFacade).partiallyLiquidateCreditAccount(\n creditAccount, token, repaidAmount, minSeizedAmount, treasury, priceUpdates\n );\n\n emit PartiallyLiquidateFromTreasury(creditFacade, creditAccount, msg.sender);\n }\n\n function _getMinSeizedAmount(address underlying, address token, uint256 repaidAmount)\n internal\n view\n returns (uint256)\n {\n uint256 requiredRate = minExchangeRates[underlying][token];\n if (requiredRate == 0) revert UnsupportedTokenPairException();\n\n uint256 scaleUnderlying = 10 ** IERC20Metadata(underlying).decimals();\n uint256 scaleToken = 10 ** IERC20Metadata(token).decimals();\n\n return repaidAmount * requiredRate * scaleToken / (PERCENTAGE_FACTOR * scaleUnderlying);\n }\n\n function _transferUnderlying(address underlying, address wrappedUnderlying, uint256 amount) internal {\n if (wrappedUnderlying != address(0)) {\n if (IERC4626(wrappedUnderlying).asset() != underlying) revert IncorrectWrappedUnderlyingException();\n uint256 wrappedAssets = IERC4626(wrappedUnderlying).maxWithdraw(treasury);\n if (wrappedAssets < amount) revert InsufficientTreasuryFundsException();\n IERC4626(wrappedUnderlying).withdraw(amount, address(this), treasury);\n } else {\n uint256 balance = IERC20(underlying).balanceOf(treasury);\n if (balance < amount) revert InsufficientTreasuryFundsException();\n IERC20(underlying).safeTransferFrom(treasury, address(this), amount);\n }\n }\n}\n","keccak256":"0xfb8aaac9f8ae78f30cc3dfee95729d0ab92aa2fbdfb4f69e3f3ddd4fcc82a50b","license":"BUSL-1.1"},"lib/@1inch/solidity-utils/contracts/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\ninterface IDaiLikePermit {\n function permit(\n address holder,\n address spender,\n uint256 nonce,\n uint256 expiry,\n bool allowed,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n}\n","keccak256":"0xbbb219886412a339a7f84b0850f700311dd2b3a106919ae54fa0a215d847a3b2","license":"MIT"},"lib/@1inch/solidity-utils/contracts/interfaces/IPermit2.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\ninterface IPermit2 {\n struct PermitDetails {\n // ERC20 token address\n address token;\n // the maximum amount allowed to spend\n uint160 amount;\n // timestamp at which a spender's token allowances become invalid\n uint48 expiration;\n // an incrementing value indexed per owner,token,and spender for each signature\n uint48 nonce;\n }\n /// @notice The permit message signed for a single token allownce\n struct PermitSingle {\n // the permit data for a single token alownce\n PermitDetails details;\n // address permissioned on the allowed tokens\n address spender;\n // deadline on the permit signature\n uint256 sigDeadline;\n }\n /// @notice Packed allowance\n struct PackedAllowance {\n // amount allowed\n uint160 amount;\n // permission expiry\n uint48 expiration;\n // an incrementing value indexed per owner,token,and spender for each signature\n uint48 nonce;\n }\n\n function transferFrom(address user, address spender, uint160 amount, address token) external;\n\n function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external;\n\n function allowance(address user, address token, address spender) external view returns (PackedAllowance memory);\n}\n","keccak256":"0x63209a082f66ecb584b86e412b3dd0010e9675bc19bc1f80a75437311df7ec11","license":"MIT"},"lib/@1inch/solidity-utils/contracts/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\ninterface IWETH is IERC20 {\n event Deposit(address indexed dst, uint wad);\n\n event Withdrawal(address indexed src, uint wad);\n\n function deposit() external payable;\n\n function withdraw(uint256 amount) external;\n}\n","keccak256":"0xc8132cbe41b3dc902df69adbbdf230bbde79647c676d064c58bc6092de6077d5","license":"MIT"},"lib/@1inch/solidity-utils/contracts/libraries/RevertReasonForwarder.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title Revert reason forwarder.\nlibrary RevertReasonForwarder {\n /// @dev Forwards latest externall call revert.\n function reRevert() internal pure {\n // bubble up revert reason from latest external call\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n let ptr := mload(0x40)\n returndatacopy(ptr, 0, returndatasize())\n revert(ptr, returndatasize())\n }\n }\n}\n","keccak256":"0x953c4a195ae066e90aac2ccfcef3121e4c5b74f2cf7cb4add341a7df7df2d00e","license":"MIT"},"lib/@1inch/solidity-utils/contracts/libraries/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol\";\nimport \"../interfaces/IDaiLikePermit.sol\";\nimport \"../interfaces/IPermit2.sol\";\nimport \"../interfaces/IWETH.sol\";\nimport \"../libraries/RevertReasonForwarder.sol\";\n\n/**\n * @title Implements efficient safe methods for ERC20 interface.\n * @notice Compared to the standard ERC20, this implementation offers several enhancements:\n * 1. more gas-efficient, providing significant savings in transaction costs.\n * 2. support for different permit implementations\n * 3. forceApprove functionality\n * 4. support for WETH deposit and withdraw\n */\nlibrary SafeERC20 {\n error SafeTransferFailed();\n error SafeTransferFromFailed();\n error ForceApproveFailed();\n error SafeIncreaseAllowanceFailed();\n error SafeDecreaseAllowanceFailed();\n error SafePermitBadLength();\n error Permit2TransferAmountTooHigh();\n\n // Uniswap Permit2 address\n address private constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n bytes4 private constant _PERMIT_LENGTH_ERROR = 0x68275857; // SafePermitBadLength.selector\n uint256 private constant _RAW_CALL_GAS_LIMIT = 5000;\n\n /**\n * @notice Fetches the balance of a specific ERC20 token held by an account.\n * Consumes less gas then regular `ERC20.balanceOf`.\n * @param token The IERC20 token contract for which the balance will be fetched.\n * @param account The address of the account whose token balance will be fetched.\n * @return tokenBalance The balance of the specified ERC20 token held by the account.\n */\n function safeBalanceOf(\n IERC20 token,\n address account\n ) internal view returns(uint256 tokenBalance) {\n bytes4 selector = IERC20.balanceOf.selector;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n mstore(0x00, selector)\n mstore(0x04, account)\n let success := staticcall(gas(), token, 0x00, 0x24, 0x00, 0x20)\n tokenBalance := mload(0)\n\n if or(iszero(success), lt(returndatasize(), 0x20)) {\n let ptr := mload(0x40)\n returndatacopy(ptr, 0, returndatasize())\n revert(ptr, returndatasize())\n }\n }\n }\n\n /**\n * @notice Attempts to safely transfer tokens from one address to another.\n * @dev If permit2 is true, uses the Permit2 standard; otherwise uses the standard ERC20 transferFrom. \n * Either requires `true` in return data, or requires target to be smart-contract and empty return data.\n * @param token The IERC20 token contract from which the tokens will be transferred.\n * @param from The address from which the tokens will be transferred.\n * @param to The address to which the tokens will be transferred.\n * @param amount The amount of tokens to transfer.\n * @param permit2 If true, uses the Permit2 standard for the transfer; otherwise uses the standard ERC20 transferFrom.\n */\n function safeTransferFromUniversal(\n IERC20 token,\n address from,\n address to,\n uint256 amount,\n bool permit2\n ) internal {\n if (permit2) {\n safeTransferFromPermit2(token, from, to, amount);\n } else {\n safeTransferFrom(token, from, to, amount);\n }\n }\n\n /**\n * @notice Attempts to safely transfer tokens from one address to another using the ERC20 standard.\n * @dev Either requires `true` in return data, or requires target to be smart-contract and empty return data.\n * @param token The IERC20 token contract from which the tokens will be transferred.\n * @param from The address from which the tokens will be transferred.\n * @param to The address to which the tokens will be transferred.\n * @param amount The amount of tokens to transfer.\n */\n function safeTransferFrom(\n IERC20 token,\n address from,\n address to,\n uint256 amount\n ) internal {\n bytes4 selector = token.transferFrom.selector;\n bool success;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n let data := mload(0x40)\n\n mstore(data, selector)\n mstore(add(data, 0x04), from)\n mstore(add(data, 0x24), to)\n mstore(add(data, 0x44), amount)\n success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n if success {\n switch returndatasize()\n case 0 {\n success := gt(extcodesize(token), 0)\n }\n default {\n success := and(gt(returndatasize(), 31), eq(mload(0), 1))\n }\n }\n }\n if (!success) revert SafeTransferFromFailed();\n }\n\n /**\n * @notice Attempts to safely transfer tokens from one address to another using the Permit2 standard.\n * @dev Either requires `true` in return data, or requires target to be smart-contract and empty return data.\n * @param token The IERC20 token contract from which the tokens will be transferred.\n * @param from The address from which the tokens will be transferred.\n * @param to The address to which the tokens will be transferred.\n * @param amount The amount of tokens to transfer.\n */\n function safeTransferFromPermit2(\n IERC20 token,\n address from,\n address to,\n uint256 amount\n ) internal {\n if (amount > type(uint160).max) revert Permit2TransferAmountTooHigh();\n bytes4 selector = IPermit2.transferFrom.selector;\n bool success;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n let data := mload(0x40)\n\n mstore(data, selector)\n mstore(add(data, 0x04), from)\n mstore(add(data, 0x24), to)\n mstore(add(data, 0x44), amount)\n mstore(add(data, 0x64), token)\n success := call(gas(), _PERMIT2, 0, data, 0x84, 0x0, 0x0)\n if success {\n success := gt(extcodesize(_PERMIT2), 0)\n }\n }\n if (!success) revert SafeTransferFromFailed();\n }\n\n /**\n * @notice Attempts to safely transfer tokens to another address.\n * @dev Either requires `true` in return data, or requires target to be smart-contract and empty return data.\n * @param token The IERC20 token contract from which the tokens will be transferred.\n * @param to The address to which the tokens will be transferred.\n * @param value The amount of tokens to transfer.\n */\n function safeTransfer(\n IERC20 token,\n address to,\n uint256 value\n ) internal {\n if (!_makeCall(token, token.transfer.selector, to, value)) {\n revert SafeTransferFailed();\n }\n }\n\n /**\n * @notice Attempts to approve a spender to spend a certain amount of tokens.\n * @dev If `approve(from, to, amount)` fails, it tries to set the allowance to zero, and retries the `approve` call.\n * @param token The IERC20 token contract on which the call will be made.\n * @param spender The address which will spend the funds.\n * @param value The amount of tokens to be spent.\n */\n function forceApprove(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n if (!_makeCall(token, token.approve.selector, spender, value)) {\n if (\n !_makeCall(token, token.approve.selector, spender, 0) ||\n !_makeCall(token, token.approve.selector, spender, value)\n ) {\n revert ForceApproveFailed();\n }\n }\n }\n\n /**\n * @notice Safely increases the allowance of a spender.\n * @dev Increases with safe math check. Checks if the increased allowance will overflow, if yes, then it reverts the transaction.\n * Then uses `forceApprove` to increase the allowance.\n * @param token The IERC20 token contract on which the call will be made.\n * @param spender The address which will spend the funds.\n * @param value The amount of tokens to increase the allowance by.\n */\n function safeIncreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n uint256 allowance = token.allowance(address(this), spender);\n if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n forceApprove(token, spender, allowance + value);\n }\n\n /**\n * @notice Safely decreases the allowance of a spender.\n * @dev Decreases with safe math check. Checks if the decreased allowance will underflow, if yes, then it reverts the transaction.\n * Then uses `forceApprove` to increase the allowance.\n * @param token The IERC20 token contract on which the call will be made.\n * @param spender The address which will spend the funds.\n * @param value The amount of tokens to decrease the allowance by.\n */\n function safeDecreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n uint256 allowance = token.allowance(address(this), spender);\n if (value > allowance) revert SafeDecreaseAllowanceFailed();\n forceApprove(token, spender, allowance - value);\n }\n\n /**\n * @notice Attempts to execute the `permit` function on the provided token with the sender and contract as parameters.\n * Permit type is determined automatically based on permit calldata (IERC20Permit, IDaiLikePermit, and IPermit2).\n * @dev Wraps `tryPermit` function and forwards revert reason if permit fails.\n * @param token The IERC20 token to execute the permit function on.\n * @param permit The permit data to be used in the function call.\n */\n function safePermit(IERC20 token, bytes calldata permit) internal {\n if (!tryPermit(token, msg.sender, address(this), permit)) RevertReasonForwarder.reRevert();\n }\n\n /**\n * @notice Attempts to execute the `permit` function on the provided token with custom owner and spender parameters. \n * Permit type is determined automatically based on permit calldata (IERC20Permit, IDaiLikePermit, and IPermit2).\n * @dev Wraps `tryPermit` function and forwards revert reason if permit fails.\n * @param token The IERC20 token to execute the permit function on.\n * @param owner The owner of the tokens for which the permit is made.\n * @param spender The spender allowed to spend the tokens by the permit.\n * @param permit The permit data to be used in the function call.\n */\n function safePermit(IERC20 token, address owner, address spender, bytes calldata permit) internal {\n if (!tryPermit(token, owner, spender, permit)) RevertReasonForwarder.reRevert();\n }\n\n /**\n * @notice Attempts to execute the `permit` function on the provided token with the sender and contract as parameters.\n * @dev Invokes `tryPermit` with sender as owner and contract as spender.\n * @param token The IERC20 token to execute the permit function on.\n * @param permit The permit data to be used in the function call.\n * @return success Returns true if the permit function was successfully executed, false otherwise.\n */\n function tryPermit(IERC20 token, bytes calldata permit) internal returns(bool success) {\n return tryPermit(token, msg.sender, address(this), permit);\n }\n\n /**\n * @notice The function attempts to call the permit function on a given ERC20 token.\n * @dev The function is designed to support a variety of permit functions, namely: IERC20Permit, IDaiLikePermit, and IPermit2.\n * It accommodates both Compact and Full formats of these permit types.\n * Please note, it is expected that the `expiration` parameter for the compact Permit2 and the `deadline` parameter \n * for the compact Permit are to be incremented by one before invoking this function. This approach is motivated by\n * gas efficiency considerations; as the unlimited expiration period is likely to be the most common scenario, and \n * zeros are cheaper to pass in terms of gas cost. Thus, callers should increment the expiration or deadline by one\n * before invocation for optimized performance.\n * @param token The address of the ERC20 token on which to call the permit function.\n * @param owner The owner of the tokens. This address should have signed the off-chain permit.\n * @param spender The address which will be approved for transfer of tokens.\n * @param permit The off-chain permit data, containing different fields depending on the type of permit function.\n * @return success A boolean indicating whether the permit call was successful.\n */\n function tryPermit(IERC20 token, address owner, address spender, bytes calldata permit) internal returns(bool success) {\n // load function selectors for different permit standards\n bytes4 permitSelector = IERC20Permit.permit.selector;\n bytes4 daiPermitSelector = IDaiLikePermit.permit.selector;\n bytes4 permit2Selector = IPermit2.permit.selector;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n let ptr := mload(0x40)\n\n // Switch case for different permit lengths, indicating different permit standards\n switch permit.length\n // Compact IERC20Permit\n case 100 {\n mstore(ptr, permitSelector) // store selector\n mstore(add(ptr, 0x04), owner) // store owner\n mstore(add(ptr, 0x24), spender) // store spender\n\n // Compact IERC20Permit.permit(uint256 value, uint32 deadline, uint256 r, uint256 vs)\n { // stack too deep\n let deadline := shr(224, calldataload(add(permit.offset, 0x20))) // loads permit.offset 0x20..0x23\n let vs := calldataload(add(permit.offset, 0x44)) // loads permit.offset 0x44..0x63\n\n calldatacopy(add(ptr, 0x44), permit.offset, 0x20) // store value = copy permit.offset 0x00..0x19\n mstore(add(ptr, 0x64), sub(deadline, 1)) // store deadline = deadline - 1\n mstore(add(ptr, 0x84), add(27, shr(255, vs))) // store v = most significant bit of vs + 27 (27 or 28)\n calldatacopy(add(ptr, 0xa4), add(permit.offset, 0x24), 0x20) // store r = copy permit.offset 0x24..0x43\n mstore(add(ptr, 0xc4), shr(1, shl(1, vs))) // store s = vs without most significant bit\n }\n // IERC20Permit.permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n success := call(gas(), token, 0, ptr, 0xe4, 0, 0)\n }\n // Compact IDaiLikePermit\n case 72 {\n mstore(ptr, daiPermitSelector) // store selector\n mstore(add(ptr, 0x04), owner) // store owner\n mstore(add(ptr, 0x24), spender) // store spender\n\n // Compact IDaiLikePermit.permit(uint32 nonce, uint32 expiry, uint256 r, uint256 vs)\n { // stack too deep\n let expiry := shr(224, calldataload(add(permit.offset, 0x04))) // loads permit.offset 0x04..0x07\n let vs := calldataload(add(permit.offset, 0x28)) // loads permit.offset 0x28..0x47\n\n mstore(add(ptr, 0x44), shr(224, calldataload(permit.offset))) // store nonce = copy permit.offset 0x00..0x03\n mstore(add(ptr, 0x64), sub(expiry, 1)) // store expiry = expiry - 1\n mstore(add(ptr, 0x84), true) // store allowed = true\n mstore(add(ptr, 0xa4), add(27, shr(255, vs))) // store v = most significant bit of vs + 27 (27 or 28)\n calldatacopy(add(ptr, 0xc4), add(permit.offset, 0x08), 0x20) // store r = copy permit.offset 0x08..0x27\n mstore(add(ptr, 0xe4), shr(1, shl(1, vs))) // store s = vs without most significant bit\n }\n // IDaiLikePermit.permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s)\n success := call(gas(), token, 0, ptr, 0x104, 0, 0)\n }\n // IERC20Permit\n case 224 {\n mstore(ptr, permitSelector)\n calldatacopy(add(ptr, 0x04), permit.offset, permit.length) // copy permit calldata\n // IERC20Permit.permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n success := call(gas(), token, 0, ptr, 0xe4, 0, 0)\n }\n // IDaiLikePermit\n case 256 {\n mstore(ptr, daiPermitSelector)\n calldatacopy(add(ptr, 0x04), permit.offset, permit.length) // copy permit calldata\n // IDaiLikePermit.permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s)\n success := call(gas(), token, 0, ptr, 0x104, 0, 0)\n }\n // Compact IPermit2\n case 96 {\n // Compact IPermit2.permit(uint160 amount, uint32 expiration, uint32 nonce, uint32 sigDeadline, uint256 r, uint256 vs)\n mstore(ptr, permit2Selector) // store selector\n mstore(add(ptr, 0x04), owner) // store owner\n mstore(add(ptr, 0x24), token) // store token\n\n calldatacopy(add(ptr, 0x50), permit.offset, 0x14) // store amount = copy permit.offset 0x00..0x13\n // and(0xffffffffffff, ...) - conversion to uint48 \n mstore(add(ptr, 0x64), and(0xffffffffffff, sub(shr(224, calldataload(add(permit.offset, 0x14))), 1))) // store expiration = ((permit.offset 0x14..0x17 - 1) & 0xffffffffffff)\n mstore(add(ptr, 0x84), shr(224, calldataload(add(permit.offset, 0x18)))) // store nonce = copy permit.offset 0x18..0x1b\n mstore(add(ptr, 0xa4), spender) // store spender\n // and(0xffffffffffff, ...) - conversion to uint48\n mstore(add(ptr, 0xc4), and(0xffffffffffff, sub(shr(224, calldataload(add(permit.offset, 0x1c))), 1))) // store sigDeadline = ((permit.offset 0x1c..0x1f - 1) & 0xffffffffffff)\n mstore(add(ptr, 0xe4), 0x100) // store offset = 256\n mstore(add(ptr, 0x104), 0x40) // store length = 64\n calldatacopy(add(ptr, 0x124), add(permit.offset, 0x20), 0x20) // store r = copy permit.offset 0x20..0x3f\n calldatacopy(add(ptr, 0x144), add(permit.offset, 0x40), 0x20) // store vs = copy permit.offset 0x40..0x5f\n // IPermit2.permit(address owner, PermitSingle calldata permitSingle, bytes calldata signature)\n success := call(gas(), _PERMIT2, 0, ptr, 0x164, 0, 0)\n }\n // IPermit2\n case 352 {\n mstore(ptr, permit2Selector)\n calldatacopy(add(ptr, 0x04), permit.offset, permit.length) // copy permit calldata\n // IPermit2.permit(address owner, PermitSingle calldata permitSingle, bytes calldata signature)\n success := call(gas(), _PERMIT2, 0, ptr, 0x164, 0, 0)\n }\n // Unknown\n default {\n mstore(ptr, _PERMIT_LENGTH_ERROR)\n revert(ptr, 4)\n }\n }\n }\n\n /**\n * @dev Executes a low level call to a token contract, making it resistant to reversion and erroneous boolean returns.\n * @param token The IERC20 token contract on which the call will be made.\n * @param selector The function signature that is to be called on the token contract.\n * @param to The address to which the token amount will be transferred.\n * @param amount The token amount to be transferred.\n * @return success A boolean indicating if the call was successful. Returns 'true' on success and 'false' on failure. \n * In case of success but no returned data, validates that the contract code exists.\n * In case of returned data, ensures that it's a boolean `true`.\n */\n function _makeCall(\n IERC20 token,\n bytes4 selector,\n address to,\n uint256 amount\n ) private returns (bool success) {\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n let data := mload(0x40)\n\n mstore(data, selector)\n mstore(add(data, 0x04), to)\n mstore(add(data, 0x24), amount)\n success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n if success {\n switch returndatasize()\n case 0 {\n success := gt(extcodesize(token), 0)\n }\n default {\n success := and(gt(returndatasize(), 31), eq(mload(0), 1))\n }\n }\n }\n }\n\n /**\n * @notice Safely deposits a specified amount of Ether into the IWETH contract. Consumes less gas then regular `IWETH.deposit`.\n * @param weth The IWETH token contract.\n * @param amount The amount of Ether to deposit into the IWETH contract.\n */\n function safeDeposit(IWETH weth, uint256 amount) internal {\n if (amount > 0) {\n bytes4 selector = IWETH.deposit.selector;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n mstore(0, selector)\n if iszero(call(gas(), weth, amount, 0, 4, 0, 0)) {\n returndatacopy(0, 0, returndatasize())\n revert(0, returndatasize())\n }\n }\n }\n }\n\n /**\n * @notice Safely withdraws a specified amount of wrapped Ether from the IWETH contract. Consumes less gas then regular `IWETH.withdraw`.\n * @dev Uses inline assembly to interact with the IWETH contract.\n * @param weth The IWETH token contract.\n * @param amount The amount of wrapped Ether to withdraw from the IWETH contract.\n */\n function safeWithdraw(IWETH weth, uint256 amount) internal {\n bytes4 selector = IWETH.withdraw.selector;\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n mstore(0, selector)\n mstore(4, amount)\n if iszero(call(gas(), weth, 0, 0, 0x24, 0, 0)) {\n let ptr := mload(0x40)\n returndatacopy(ptr, 0, returndatasize())\n revert(ptr, returndatasize())\n }\n }\n }\n\n /**\n * @notice Safely withdraws a specified amount of wrapped Ether from the IWETH contract to a specified recipient.\n * Consumes less gas then regular `IWETH.withdraw`.\n * @param weth The IWETH token contract.\n * @param amount The amount of wrapped Ether to withdraw from the IWETH contract.\n * @param to The recipient of the withdrawn Ether.\n */\n function safeWithdrawTo(IWETH weth, uint256 amount, address to) internal {\n safeWithdraw(weth, amount);\n if (to != address(this)) {\n assembly (\"memory-safe\") { // solhint-disable-line no-inline-assembly\n if iszero(call(_RAW_CALL_GAS_LIMIT, to, amount, 0, 0, 0, 0)) {\n let ptr := mload(0x40)\n returndatacopy(ptr, 0, returndatasize())\n revert(ptr, returndatasize())\n }\n }\n }\n }\n}\n","keccak256":"0x1c050d9eea8792471f3e92a8423c1900287452fe2cb8457208f8955e4ca556cc","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/ICreditConfiguratorV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IACLTrait} from \"./base/IACLTrait.sol\";\nimport {IVersion} from \"./base/IVersion.sol\";\n\nenum AllowanceAction {\n FORBID,\n ALLOW\n}\n\ninterface ICreditConfiguratorV3Events {\n // ------ //\n // TOKENS //\n // ------ //\n\n /// @notice Emitted when a token is made recognizable as collateral in the credit manager\n event AddCollateralToken(address indexed token);\n\n /// @notice Emitted when a new collateral token liquidation threshold is set\n event SetTokenLiquidationThreshold(address indexed token, uint16 liquidationThreshold);\n\n /// @notice Emitted when a collateral token liquidation threshold ramping is scheduled\n event ScheduleTokenLiquidationThresholdRamp(\n address indexed token,\n uint16 liquidationThresholdInitial,\n uint16 liquidationThresholdFinal,\n uint40 timestampRampStart,\n uint40 timestampRampEnd\n );\n\n /// @notice Emitted when a collateral token is forbidden\n event ForbidToken(address indexed token);\n\n /// @notice Emitted when a previously forbidden collateral token is allowed\n event AllowToken(address indexed token);\n\n // -------- //\n // ADAPTERS //\n // -------- //\n\n /// @notice Emitted when a new adapter and its target contract are allowed in the credit manager\n event AllowAdapter(address indexed targetContract, address indexed adapter);\n\n /// @notice Emitted when adapter and its target contract are forbidden in the credit manager\n event ForbidAdapter(address indexed targetContract, address indexed adapter);\n\n // -------------- //\n // CREDIT MANAGER //\n // -------------- //\n\n /// @notice Emitted when new fee parameters are set in the credit manager\n event UpdateFees(\n uint16 feeLiquidation, uint16 liquidationPremium, uint16 feeLiquidationExpired, uint16 liquidationPremiumExpired\n );\n\n // -------- //\n // UPGRADES //\n // -------- //\n\n /// @notice Emitted when a new price oracle is set in the credit manager\n event SetPriceOracle(address indexed priceOracle);\n\n /// @notice Emitted when a new facade is connected to the credit manager\n event SetCreditFacade(address indexed creditFacade);\n\n /// @notice Emitted when credit manager's configurator contract is upgraded\n event CreditConfiguratorUpgraded(address indexed creditConfigurator);\n\n // ------------- //\n // CREDIT FACADE //\n // ------------- //\n\n /// @notice Emitted when new debt principal limits are set\n event SetBorrowingLimits(uint256 minDebt, uint256 maxDebt);\n\n /// @notice Emitted when a new max debt per block multiplier is set\n event SetMaxDebtPerBlockMultiplier(uint8 maxDebtPerBlockMultiplier);\n\n /// @notice Emitted when new loss policy is set\n event SetLossPolicy(address indexed lossPolicy);\n\n /// @notice Emitted when a new expiration timestamp is set in the credit facade\n event SetExpirationDate(uint40 expirationDate);\n}\n\n/// @title Credit configurator V3 interface\ninterface ICreditConfiguratorV3 is IVersion, IACLTrait, ICreditConfiguratorV3Events {\n function creditManager() external view returns (address);\n\n function creditFacade() external view returns (address);\n\n function underlying() external view returns (address);\n\n // ------ //\n // TOKENS //\n // ------ //\n\n function makeAllTokensQuoted() external;\n\n function addCollateralToken(address token, uint16 liquidationThreshold) external;\n\n function setLiquidationThreshold(address token, uint16 liquidationThreshold) external;\n\n function rampLiquidationThreshold(\n address token,\n uint16 liquidationThresholdFinal,\n uint40 rampStart,\n uint24 rampDuration\n ) external;\n\n function forbidToken(address token) external;\n\n function allowToken(address token) external;\n\n // -------- //\n // ADAPTERS //\n // -------- //\n\n function allowedAdapters() external view returns (address[] memory);\n\n function allowAdapter(address adapter) external;\n\n function forbidAdapter(address adapter) external;\n\n // -------------- //\n // CREDIT MANAGER //\n // -------------- //\n\n function setFees(\n uint16 feeLiquidation,\n uint16 liquidationPremium,\n uint16 feeLiquidationExpired,\n uint16 liquidationPremiumExpired\n ) external;\n\n // -------- //\n // UPGRADES //\n // -------- //\n\n function setPriceOracle(address newPriceOracle) external;\n\n function setCreditFacade(address newCreditFacade, bool migrateParams) external;\n\n function upgradeCreditConfigurator(address newCreditConfigurator) external;\n\n // ------------- //\n // CREDIT FACADE //\n // ------------- //\n\n function setDebtLimits(uint128 newMinDebt, uint128 newMaxDebt) external;\n\n function setMaxDebtPerBlockMultiplier(uint8 newMaxDebtLimitPerBlockMultiplier) external;\n\n function forbidBorrowing() external;\n\n function setLossPolicy(address newLossPolicy) external;\n\n function setExpirationDate(uint40 newExpirationDate) external;\n}\n","keccak256":"0xa5a4cf1ca73753cf12f179a23211b0684f6e820cf7b3c9802f88090c928e8158","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {AllowanceAction} from \"./ICreditConfiguratorV3.sol\";\nimport \"./ICreditFacadeV3Multicall.sol\";\nimport {IACLTrait} from \"./base/IACLTrait.sol\";\nimport {PriceUpdate} from \"./base/IPriceFeedStore.sol\";\nimport {IVersion} from \"./base/IVersion.sol\";\n\n/// @notice Multicall element\n/// @param target Call target, which is either credit facade or adapter\n/// @param callData Call data\nstruct MultiCall {\n address target;\n bytes callData;\n}\n\n/// @notice Debt limits packed into a single slot\n/// @param minDebt Minimum debt amount per credit account\n/// @param maxDebt Maximum debt amount per credit account\nstruct DebtLimits {\n uint128 minDebt;\n uint128 maxDebt;\n}\n\n/// @notice Collateral check params\n/// @param collateralHints Optional array of token masks to check first to reduce the amount of computation\n/// when known subset of account's collateral tokens covers all the debt\n/// @param minHealthFactor Min account's health factor in bps in order not to revert\nstruct FullCheckParams {\n uint256[] collateralHints;\n uint16 minHealthFactor;\n}\n\ninterface ICreditFacadeV3Events {\n /// @notice Emitted when a new credit account is opened\n event OpenCreditAccount(\n address indexed creditAccount, address indexed onBehalfOf, address indexed caller, uint256 referralCode\n );\n\n /// @notice Emitted when account is closed\n event CloseCreditAccount(address indexed creditAccount, address indexed borrower);\n\n /// @notice Emitted when account is liquidated\n event LiquidateCreditAccount(\n address indexed creditAccount, address indexed liquidator, address to, uint256 remainingFunds\n );\n\n /// @notice Emitted when account is partially liquidated\n event PartiallyLiquidateCreditAccount(\n address indexed creditAccount,\n address indexed token,\n address indexed liquidator,\n uint256 repaidDebt,\n uint256 seizedCollateral,\n uint256 fee\n );\n\n /// @notice Emitted when collateral is added to account\n event AddCollateral(address indexed creditAccount, address indexed token, uint256 amount);\n\n /// @notice Emitted when collateral is withdrawn from account\n event WithdrawCollateral(address indexed creditAccount, address indexed token, uint256 amount, address to);\n\n /// @notice Emitted when a multicall is started\n event StartMultiCall(address indexed creditAccount, address indexed caller);\n\n /// @notice Emitted when phantom token is withdrawn by account\n event WithdrawPhantomToken(address indexed creditAccount, address indexed token, uint256 amount);\n\n /// @notice Emitted when a call from account to an external contract is made during a multicall\n event Execute(address indexed creditAccount, address indexed targetContract);\n\n /// @notice Emitted when a multicall is finished\n event FinishMultiCall();\n}\n\n/// @title Credit facade V3 interface\ninterface ICreditFacadeV3 is IVersion, IACLTrait, ICreditFacadeV3Events {\n function creditManager() external view returns (address);\n\n function underlying() external view returns (address);\n\n function treasury() external view returns (address);\n\n function priceFeedStore() external view returns (address);\n\n function degenNFT() external view returns (address);\n\n function weth() external view returns (address);\n\n function botList() external view returns (address);\n\n function maxDebtPerBlockMultiplier() external view returns (uint8);\n\n function maxQuotaMultiplier() external view returns (uint256);\n\n function expirable() external view returns (bool);\n\n function expirationDate() external view returns (uint40);\n\n function debtLimits() external view returns (uint128 minDebt, uint128 maxDebt);\n\n function lossPolicy() external view returns (address);\n\n function forbiddenTokenMask() external view returns (uint256);\n\n // ------------------ //\n // ACCOUNT MANAGEMENT //\n // ------------------ //\n\n function openCreditAccount(address onBehalfOf, MultiCall[] calldata calls, uint256 referralCode)\n external\n payable\n returns (address creditAccount);\n\n function closeCreditAccount(address creditAccount, MultiCall[] calldata calls) external payable;\n\n function liquidateCreditAccount(\n address creditAccount,\n address to,\n MultiCall[] calldata calls,\n bytes memory lossPolicyData\n ) external;\n\n function liquidateCreditAccount(address creditAccount, address to, MultiCall[] calldata calls) external;\n\n function partiallyLiquidateCreditAccount(\n address creditAccount,\n address token,\n uint256 repaidAmount,\n uint256 minSeizedAmount,\n address to,\n PriceUpdate[] calldata priceUpdates\n ) external returns (uint256 seizedAmount);\n\n function multicall(address creditAccount, MultiCall[] calldata calls) external payable;\n\n function botMulticall(address creditAccount, MultiCall[] calldata calls) external;\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function setExpirationDate(uint40 newExpirationDate) external;\n\n function setDebtLimits(uint128 newMinDebt, uint128 newMaxDebt, uint8 newMaxDebtPerBlockMultiplier) external;\n\n function setLossPolicy(address newLossPolicy) external;\n\n function setTokenAllowance(address token, AllowanceAction allowance) external;\n\n function pause() external;\n\n function unpause() external;\n}\n","keccak256":"0xdb6553c77c1a2f678aa04c1c168e8b241b9b18d94e3ef1f0ca61639a9253ee6d","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3Multicall.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {BalanceDelta} from \"../libraries/BalancesLogic.sol\";\nimport {PriceUpdate} from \"./base/IPriceFeedStore.sol\";\n\n// ----------- //\n// PERMISSIONS //\n// ----------- //\n\n// NOTE: permissions 1 << 3, 1 << 4 and 1 << 7 were used by now deprecated methods, thus non-consecutive values\n\nuint192 constant ADD_COLLATERAL_PERMISSION = 1 << 0;\nuint192 constant INCREASE_DEBT_PERMISSION = 1 << 1;\nuint192 constant DECREASE_DEBT_PERMISSION = 1 << 2;\nuint192 constant WITHDRAW_COLLATERAL_PERMISSION = 1 << 5;\nuint192 constant UPDATE_QUOTA_PERMISSION = 1 << 6;\nuint192 constant SET_BOT_PERMISSIONS_PERMISSION = 1 << 8;\nuint192 constant EXTERNAL_CALLS_PERMISSION = 1 << 16;\n\nuint192 constant ALL_PERMISSIONS = ADD_COLLATERAL_PERMISSION | WITHDRAW_COLLATERAL_PERMISSION | UPDATE_QUOTA_PERMISSION\n | INCREASE_DEBT_PERMISSION | DECREASE_DEBT_PERMISSION | SET_BOT_PERMISSIONS_PERMISSION | EXTERNAL_CALLS_PERMISSION;\nuint192 constant OPEN_CREDIT_ACCOUNT_PERMISSIONS = ALL_PERMISSIONS & ~DECREASE_DEBT_PERMISSION;\nuint192 constant CLOSE_CREDIT_ACCOUNT_PERMISSIONS = ALL_PERMISSIONS & ~INCREASE_DEBT_PERMISSION;\nuint192 constant LIQUIDATE_CREDIT_ACCOUNT_PERMISSIONS =\n EXTERNAL_CALLS_PERMISSION | ADD_COLLATERAL_PERMISSION | WITHDRAW_COLLATERAL_PERMISSION;\n\n// ----- //\n// FLAGS //\n// ----- //\n\n/// @dev Indicates that collateral check after the multicall can be skipped, set to true on account closure or liquidation\nuint256 constant SKIP_COLLATERAL_CHECK_FLAG = 1 << 192;\n\n/// @dev Indicates that external calls from credit account to adapters were made during multicall,\n/// set to true on the first call to the adapter\nuint256 constant EXTERNAL_CONTRACT_WAS_CALLED_FLAG = 1 << 193;\n\n/// @dev Indicates that the price updates call should be skipped, set to true on liquidation when the first call\n/// of the multicall is `onDemandPriceUpdates`\nuint256 constant SKIP_PRICE_UPDATES_CALL_FLAG = 1 << 194;\n\n/// @dev Indicates that collateral check must revert if any forbidden token is encountered on the account,\n/// set to true after risky operations, such as `increaseDebt` or `withdrawCollateral`\nuint256 constant REVERT_ON_FORBIDDEN_TOKENS_FLAG = 1 << 195;\n\n/// @dev Indicates that collateral check must be performed using safe prices, set to true on `withdrawCollateral`\n/// or if account has enabled forbidden tokens\nuint256 constant USE_SAFE_PRICES_FLAG = 1 << 196;\n\n/// @title Credit facade V3 multicall interface\n/// @dev Unless specified otherwise, all these methods are only available in `openCreditAccount`,\n/// `closeCreditAccount`, `multicall`, and, with account owner's permission, `botMulticall`\ninterface ICreditFacadeV3Multicall {\n /// @notice Applies on-demand price feed updates\n /// @param updates Array of price updates, see `PriceUpdate` for details\n /// @dev Reverts if placed not at the first position in the multicall\n /// @dev This method is available in all kinds of multicalls\n function onDemandPriceUpdates(PriceUpdate[] calldata updates) external;\n\n /// @notice Stores expected token balances (current balance + delta) after operations for a slippage check.\n /// Normally, a check is performed automatically at the end of the multicall, but more fine-grained\n /// behavior can be achieved by placing `storeExpectedBalances` and `compareBalances` where needed.\n /// @param balanceDeltas Array of (token, minBalanceDelta) pairs, deltas are allowed to be negative\n /// @dev Reverts if expected balances are already set\n /// @dev This method is available in all kinds of multicalls\n function storeExpectedBalances(BalanceDelta[] calldata balanceDeltas) external;\n\n /// @notice Performs a slippage check ensuring that current token balances are greater than saved expected ones\n /// @dev Resets stored expected balances\n /// @dev Reverts if expected balances are not stored\n /// @dev This method is available in all kinds of multicalls\n function compareBalances() external;\n\n /// @notice Adds collateral to account.\n /// Only the underlying token counts towards account's collateral value by default, while all other tokens\n /// must be enabled as collateral by \"purchasing\" quota for it. Holding non-enabled token on account with\n /// non-zero debt poses a risk of losing it entirely to the liquidator. Adding non-enabled tokens is still\n /// supported to allow users to later swap them into enabled ones in the same multicall.\n /// @param token Token to add\n /// @param amount Amount to add\n /// @dev Requires token approval from caller to the credit manager\n /// @dev This method can also be called during liquidation\n function addCollateral(address token, uint256 amount) external;\n\n /// @notice Adds collateral to account using signed EIP-2612 permit message.\n /// Only the underlying token counts towards account's collateral value by default, while all other tokens\n /// must be enabled as collateral by \"purchasing\" quota for it. Holding non-enabled token on account with\n /// non-zero debt poses a risk of losing it entirely to the liquidator. Adding non-enabled tokens is still\n /// supported to allow users to later swap them into enabled ones in the same multicall.\n /// @param token Token to add\n /// @param amount Amount to add\n /// @param deadline Permit deadline\n /// @dev `v`, `r`, `s` must be a valid signature of the permit message from caller to the credit manager\n /// @dev This method can also be called during liquidation\n function addCollateralWithPermit(address token, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n external;\n\n /// @notice Increases account's debt\n /// @param amount Underlying amount to borrow\n /// @dev Increasing debt is prohibited when closing an account\n /// @dev Increasing debt is prohibited if it was previously updated in the same block\n /// @dev The resulting debt amount must be within allowed limits\n /// @dev Increasing debt is prohibited if there are forbidden tokens enabled as collateral on the account\n /// @dev After debt increase, total amount borrowed by the credit manager in the current block must not exceed\n /// the limit defined in the facade\n function increaseDebt(uint256 amount) external;\n\n /// @notice Decreases account's debt\n /// @param amount Underlying amount to repay, value above account's total debt indicates full repayment\n /// @dev Decreasing debt is prohibited when opening an account\n /// @dev Decreasing debt is prohibited if it was previously updated in the same block\n /// @dev The resulting debt amount must be above allowed minimum or zero (maximum is not checked here\n /// to allow small repayments and partial liquidations in case configurator lowers it)\n /// @dev Full repayment brings account into a special mode that skips collateral checks and thus requires\n /// an account to have no potential debt sources, e.g., all quotas must be disabled\n function decreaseDebt(uint256 amount) external;\n\n /// @notice Updates account's quota for a token\n /// @param token Collateral token to update the quota for (can't be underlying)\n /// @param quotaChange Desired quota change in underlying token units (`type(int96).min` to disable quota)\n /// @param minQuota Minimum resulting account's quota for token required not to revert\n /// @dev Enables token as collateral if quota is increased from zero, disables if decreased to zero\n /// @dev Quota increase is prohibited for forbidden tokens\n /// @dev Quota update is prohibited if account has zero debt\n /// @dev Resulting account's quota for token must not exceed the limit defined in the facade\n function updateQuota(address token, int96 quotaChange, uint96 minQuota) external;\n\n /// @notice Withdraws collateral from account\n /// @param token Token to withdraw\n /// @param amount Amount to withdraw, `type(uint256).max` to withdraw all balance\n /// @param to Token recipient\n /// @dev This method can also be called during liquidation\n /// @dev Withdrawals are prohibited in multicalls if there are forbidden tokens enabled as collateral on the account\n /// @dev Withdrawals activate safe pricing (min of main and reserve feeds) in collateral check\n /// @dev If `token` is a phantom token, it's withdrawn first, and its `depositedToken` is then sent to the recipient.\n /// No slippage prevention mechanism is provided as withdrawals are assumed to happen at non-manipulatable rate.\n /// Although an adapter call is made in process, permission for external calls is not required.\n function withdrawCollateral(address token, uint256 amount, address to) external;\n\n /// @notice Sets advanced collateral check parameters\n /// @param collateralHints Optional array of token masks to check first to reduce the amount of computation\n /// when known subset of account's collateral tokens covers all the debt. Underlying token is always\n /// checked last so it's forbidden to pass its mask.\n /// @param minHealthFactor Min account's health factor in bps in order not to revert, must be at least 10000\n /// @dev This method can't be called during closure or liquidation\n function setFullCheckParams(uint256[] calldata collateralHints, uint16 minHealthFactor) external;\n\n /// @notice Sets `bot`'s permissions to manage account to `permissions`\n /// @param bot Bot to set permissions for\n /// @param permissions A bitmask encoding bot permissions\n /// @dev Reverts if `permissions` has unexpected bits enabled or doesn't match permissions required by `bot`\n function setBotPermissions(address bot, uint192 permissions) external;\n}\n","keccak256":"0x130785f3b32ae7adf27e6d1e1ef8e49637eba98122440d169869121421e8c7d4","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IVersion} from \"./base/IVersion.sol\";\n\n/// @notice Debt management type\n/// - `INCREASE_DEBT` borrows additional funds from the pool, updates account's debt and cumulative interest index\n/// - `DECREASE_DEBT` repays debt components (quota interest and fees -> base interest and fees -> debt principal)\n/// and updates all corresponding state variables (base interest index, quota interest and fees, debt).\n/// When repaying all the debt, ensures that account has no enabled quotas.\nenum ManageDebtAction {\n INCREASE_DEBT,\n DECREASE_DEBT\n}\n\n/// @notice Collateral/debt calculation mode\n/// - `GENERIC_PARAMS` returns generic data like account debt and cumulative indexes\n/// - `DEBT_ONLY` is same as `GENERIC_PARAMS` but includes more detailed debt info, like accrued base/quota\n/// interest and fees\n/// - `FULL_COLLATERAL_CHECK_LAZY` checks whether account is sufficiently collateralized in a lazy fashion,\n/// i.e. it stops iterating over collateral tokens once TWV reaches the desired target.\n/// Since it may return underestimated TWV, it's only available for internal use.\n/// - `DEBT_COLLATERAL` is same as `DEBT_ONLY` but also returns total value and total LT-weighted value of\n/// account's tokens, this mode is used during account liquidation\n/// - `DEBT_COLLATERAL_SAFE_PRICES` is same as `DEBT_COLLATERAL` but uses safe prices from price oracle\nenum CollateralCalcTask {\n GENERIC_PARAMS,\n DEBT_ONLY,\n FULL_COLLATERAL_CHECK_LAZY,\n DEBT_COLLATERAL,\n DEBT_COLLATERAL_SAFE_PRICES\n}\n\nstruct CreditAccountInfo {\n uint256 debt;\n uint256 cumulativeIndexLastUpdate;\n uint128 cumulativeQuotaInterest;\n uint128 quotaFees;\n uint256 enabledTokensMask;\n uint16 flags;\n uint64 lastDebtUpdate;\n address borrower;\n}\n\nstruct CollateralDebtData {\n uint256 debt;\n uint256 cumulativeIndexNow;\n uint256 cumulativeIndexLastUpdate;\n uint128 cumulativeQuotaInterest;\n uint256 accruedInterest;\n uint256 accruedFees;\n uint256 totalDebtUSD;\n uint256 totalValue;\n uint256 totalValueUSD;\n uint256 twvUSD;\n uint256 enabledTokensMask;\n uint256 quotedTokensMask;\n address[] quotedTokens;\n address _poolQuotaKeeper;\n}\n\nstruct CollateralTokenData {\n address token;\n uint16 ltInitial;\n uint16 ltFinal;\n uint40 timestampRampStart;\n uint24 rampDuration;\n}\n\ninterface ICreditManagerV3Events {\n /// @notice Emitted when new credit configurator is set\n event SetCreditConfigurator(address indexed newConfigurator);\n}\n\n/// @title Credit manager V3 interface\ninterface ICreditManagerV3 is IVersion, ICreditManagerV3Events {\n function pool() external view returns (address);\n\n function underlying() external view returns (address);\n\n function creditFacade() external view returns (address);\n\n function creditConfigurator() external view returns (address);\n\n function accountFactory() external view returns (address);\n\n function name() external view returns (string memory);\n\n // ------------------ //\n // ACCOUNT MANAGEMENT //\n // ------------------ //\n\n function openCreditAccount(address onBehalfOf) external returns (address);\n\n function closeCreditAccount(address creditAccount) external;\n\n function liquidateCreditAccount(\n address creditAccount,\n CollateralDebtData calldata collateralDebtData,\n address to,\n bool isExpired\n ) external returns (uint256 remainingFunds, uint256 loss);\n\n function manageDebt(address creditAccount, uint256 amount, uint256 enabledTokensMask, ManageDebtAction action)\n external\n returns (uint256 newDebt, uint256, uint256);\n\n function addCollateral(address payer, address creditAccount, address token, uint256 amount)\n external\n returns (uint256);\n\n function withdrawCollateral(address creditAccount, address token, uint256 amount, address to)\n external\n returns (uint256);\n\n function externalCall(address creditAccount, address target, bytes calldata callData)\n external\n returns (bytes memory result);\n\n function approveToken(address creditAccount, address token, address spender, uint256 amount) external;\n\n // -------- //\n // ADAPTERS //\n // -------- //\n\n function adapterToContract(address adapter) external view returns (address targetContract);\n\n function contractToAdapter(address targetContract) external view returns (address adapter);\n\n function execute(bytes calldata data) external returns (bytes memory result);\n\n function approveCreditAccount(address token, uint256 amount) external;\n\n function setActiveCreditAccount(address creditAccount) external;\n\n function getActiveCreditAccountOrRevert() external view returns (address creditAccount);\n\n // ----------------- //\n // COLLATERAL CHECKS //\n // ----------------- //\n\n function priceOracle() external view returns (address);\n\n function fullCollateralCheck(\n address creditAccount,\n uint256 enabledTokensMask,\n uint256[] calldata collateralHints,\n uint16 minHealthFactor,\n bool useSafePrices\n ) external returns (uint256);\n\n function isLiquidatable(address creditAccount, uint16 minHealthFactor) external view returns (bool);\n\n function calcDebtAndCollateral(address creditAccount, CollateralCalcTask task)\n external\n view\n returns (CollateralDebtData memory cdd);\n\n // ------ //\n // QUOTAS //\n // ------ //\n\n function poolQuotaKeeper() external view returns (address);\n\n function quotedTokensMask() external view returns (uint256);\n\n function updateQuota(address creditAccount, address token, int96 quotaChange, uint96 minQuota, uint96 maxQuota)\n external\n returns (uint256 tokensToEnable, uint256 tokensToDisable);\n\n // --------------------- //\n // CREDIT MANAGER PARAMS //\n // --------------------- //\n\n function maxEnabledTokens() external view returns (uint8);\n\n function fees()\n external\n view\n returns (\n uint16 feeInterest,\n uint16 feeLiquidation,\n uint16 liquidationDiscount,\n uint16 feeLiquidationExpired,\n uint16 liquidationDiscountExpired\n );\n\n function collateralTokensCount() external view returns (uint8);\n\n function getTokenMaskOrRevert(address token) external view returns (uint256 tokenMask);\n\n function getTokenByMask(uint256 tokenMask) external view returns (address token);\n\n function liquidationThresholds(address token) external view returns (uint16 lt);\n\n function ltParams(address token)\n external\n view\n returns (uint16 ltInitial, uint16 ltFinal, uint40 timestampRampStart, uint24 rampDuration);\n\n function collateralTokenByMask(uint256 tokenMask)\n external\n view\n returns (address token, uint16 liquidationThreshold);\n\n // ------------ //\n // ACCOUNT INFO //\n // ------------ //\n\n function creditAccountInfo(address creditAccount)\n external\n view\n returns (\n uint256 debt,\n uint256 cumulativeIndexLastUpdate,\n uint128 cumulativeQuotaInterest,\n uint128 quotaFees,\n uint256 enabledTokensMask,\n uint16 flags,\n uint64 lastDebtUpdate,\n address borrower\n );\n\n function getBorrowerOrRevert(address creditAccount) external view returns (address borrower);\n\n function flagsOf(address creditAccount) external view returns (uint16);\n\n function setFlagFor(address creditAccount, uint16 flag, bool value) external;\n\n function enabledTokensMaskOf(address creditAccount) external view returns (uint256);\n\n function creditAccounts() external view returns (address[] memory);\n\n function creditAccounts(uint256 offset, uint256 limit) external view returns (address[] memory);\n\n function creditAccountsLen() external view returns (uint256);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function addToken(address token) external;\n\n function setCollateralTokenData(\n address token,\n uint16 ltInitial,\n uint16 ltFinal,\n uint40 timestampRampStart,\n uint24 rampDuration\n ) external;\n\n function setFees(\n uint16 feeInterest,\n uint16 feeLiquidation,\n uint16 liquidationDiscount,\n uint16 feeLiquidationExpired,\n uint16 liquidationDiscountExpired\n ) external;\n\n function setContractAllowance(address adapter, address targetContract) external;\n\n function setCreditFacade(address creditFacade) external;\n\n function setPriceOracle(address priceOracle) external;\n\n function setCreditConfigurator(address creditConfigurator) external;\n}\n","keccak256":"0xd84e2111433f85bdcfa6a892669d8fb0b62f94e877ac9e053339c12811d1076e","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\n// ------- //\n// GENERAL //\n// ------- //\n\n/// @notice Thrown on attempting to set an important address to zero address\nerror ZeroAddressException();\n\n/// @notice Thrown when attempting to pass a zero amount to a funding-related operation\nerror AmountCantBeZeroException();\n\n/// @notice Thrown on incorrect input parameter\nerror IncorrectParameterException();\n\n/// @notice Thrown when balance is insufficient to perform an operation\nerror InsufficientBalanceException();\n\n/// @notice Thrown if parameter is out of range\nerror ValueOutOfRangeException();\n\n/// @notice Thrown when trying to send ETH to a contract that is not allowed to receive ETH directly\nerror ReceiveIsNotAllowedException();\n\n/// @notice Thrown on attempting to set an EOA as an important contract in the system\nerror AddressIsNotContractException(address);\n\n/// @notice Thrown on attempting to receive a token that is not a collateral token or was forbidden\nerror TokenNotAllowedException();\n\n/// @notice Thrown on attempting to add a token that is already in a collateral list\nerror TokenAlreadyAddedException();\n\n/// @notice Thrown when attempting to use quota-related logic for a token that is not quoted in quota keeper\nerror TokenIsNotQuotedException();\n\n/// @notice Thrown on attempting to interact with an address that is not a valid target contract\nerror TargetContractNotAllowedException();\n\n/// @notice Thrown if function is not implemented\nerror NotImplementedException();\n\n// ------------------ //\n// CONTRACTS REGISTER //\n// ------------------ //\n\n/// @notice Thrown when an address is expected to be a registered credit manager, but is not\nerror RegisteredCreditManagerOnlyException();\n\n/// @notice Thrown when an address is expected to be a registered pool, but is not\nerror RegisteredPoolOnlyException();\n\n// ---------------- //\n// ADDRESS PROVIDER //\n// ---------------- //\n\n/// @notice Reverts if address key isn't found in address provider\nerror AddressNotFoundException();\n\n// ----------------- //\n// POOL, PQK, GAUGES //\n// ----------------- //\n\n/// @notice Thrown by pool-adjacent contracts when a credit manager being connected has a wrong pool address\nerror IncompatibleCreditManagerException();\n\n/// @notice Thrown when attempting to set an incompatible successor staking contract\nerror IncompatibleSuccessorException();\n\n/// @notice Thrown when attempting to vote in a non-approved contract\nerror VotingContractNotAllowedException();\n\n/// @notice Thrown when attempting to unvote more votes than there are\nerror InsufficientVotesException();\n\n/// @notice Thrown when attempting to borrow more than the second point on a two-point curve\nerror BorrowingMoreThanU2ForbiddenException();\n\n/// @notice Thrown when a credit manager attempts to borrow more than its limit in the current block, or in general\nerror CreditManagerCantBorrowException();\n\n/// @notice Thrown when attempting to connect a quota keeper to an incompatible pool\nerror IncompatiblePoolQuotaKeeperException();\n\n/// @notice Thrown when attempting to connect a gauge to an incompatible pool quota keeper\nerror IncompatibleGaugeException();\n\n/// @notice Thrown when the quota is outside of min/max bounds\nerror QuotaIsOutOfBoundsException();\n\n// -------------- //\n// CREDIT MANAGER //\n// -------------- //\n\n/// @notice Thrown on failing a full collateral check after multicall\nerror NotEnoughCollateralException();\n\n/// @notice Thrown if an attempt to approve a collateral token to adapter's target contract fails\nerror AllowanceFailedException();\n\n/// @notice Thrown on attempting to perform an action for a credit account that does not exist\nerror CreditAccountDoesNotExistException();\n\n/// @notice Thrown on configurator attempting to add more than 255 collateral tokens\nerror TooManyTokensException();\n\n/// @notice Thrown if more than the maximum number of tokens were enabled on a credit account\nerror TooManyEnabledTokensException();\n\n/// @notice Thrown when attempting to execute a protocol interaction without active credit account set\nerror ActiveCreditAccountNotSetException();\n\n/// @notice Thrown when trying to update credit account's debt more than once in the same block\nerror DebtUpdatedTwiceInOneBlockException();\n\n/// @notice Thrown when trying to repay all debt while having active quotas\nerror DebtToZeroWithActiveQuotasException();\n\n/// @notice Thrown when a zero-debt account attempts to update quota\nerror UpdateQuotaOnZeroDebtAccountException();\n\n/// @notice Thrown when attempting to close an account with non-zero debt\nerror CloseAccountWithNonZeroDebtException();\n\n/// @notice Thrown when value of funds remaining on the account after liquidation is insufficient\nerror InsufficientRemainingFundsException();\n\n/// @notice Thrown when Credit Facade tries to write over a non-zero active Credit Account\nerror ActiveCreditAccountOverridenException();\n\n// ------------------- //\n// CREDIT CONFIGURATOR //\n// ------------------- //\n\n/// @notice Thrown on attempting to use a non-ERC20 contract or an EOA as a token\nerror IncorrectTokenContractException();\n\n/// @notice Thrown if the newly set LT if zero or greater than the underlying's LT\nerror IncorrectLiquidationThresholdException();\n\n/// @notice Thrown if borrowing limits are incorrect: minLimit > maxLimit or maxLimit > blockLimit\nerror IncorrectLimitsException();\n\n/// @notice Thrown if the new expiration date is less than the current expiration date or current timestamp\nerror IncorrectExpirationDateException();\n\n/// @notice Thrown if a contract returns a wrong credit manager or reverts when trying to retrieve it\nerror IncompatibleContractException();\n\n/// @notice Thrown if attempting to forbid an adapter that is not registered in the credit manager\nerror AdapterIsNotRegisteredException();\n\n/// @notice Thrown if new credit configurator's set of allowed adapters differs from the current one\nerror IncorrectAdaptersSetException();\n\n/// @notice Thrown if attempting to schedule a token's LT ramping that is too short in duration\nerror RampDurationTooShortException();\n\n/// @notice Thrown if attempting to set liquidation fees such that the sum of premium and fee changes\nerror InconsistentLiquidationFeesException();\n\n/// @notice Thrown if attempting to set expired liquidation fees such that the sum of premium and fee changes\nerror InconsistentExpiredLiquidationFeesException();\n\n// ------------- //\n// CREDIT FACADE //\n// ------------- //\n\n/// @notice Thrown when attempting to perform an action that is forbidden in whitelisted mode\nerror ForbiddenInWhitelistedModeException();\n\n/// @notice Thrown if credit facade is not expirable, and attempted aciton requires expirability\nerror NotAllowedWhenNotExpirableException();\n\n/// @notice Thrown if a selector that doesn't match any allowed function is passed to the credit facade in a multicall\nerror UnknownMethodException(bytes4 selector);\n\n/// @notice Thrown if a liquidator tries to liquidate an account with a health factor above 1\nerror CreditAccountNotLiquidatableException();\n\n/// @notice Thrown if a liquidator tries to liquidate an account with loss but violates the loss policy\nerror CreditAccountNotLiquidatableWithLossException();\n\n/// @notice Thrown if too much new debt was taken within a single block\nerror BorrowedBlockLimitException();\n\n/// @notice Thrown if the new debt principal for a credit account falls outside of borrowing limits\nerror BorrowAmountOutOfLimitsException();\n\n/// @notice Thrown if a user attempts to open an account via an expired credit facade\nerror NotAllowedAfterExpirationException();\n\n/// @notice Thrown if expected balances are attempted to be set twice without performing a slippage check\nerror ExpectedBalancesAlreadySetException();\n\n/// @notice Thrown if attempting to perform a slippage check when excepted balances are not set\nerror ExpectedBalancesNotSetException();\n\n/// @notice Thrown if balance of at least one token is less than expected during a slippage check\nerror BalanceLessThanExpectedException(address token);\n\n/// @notice Thrown when trying to perform an action that is forbidden when credit account has enabled forbidden tokens\nerror ForbiddenTokensException(uint256 forbiddenTokensMask);\n\n/// @notice Thrown when forbidden token quota is increased during the multicall\nerror ForbiddenTokenQuotaIncreasedException(address token);\n\n/// @notice Thrown when enabled forbidden token balance is increased during the multicall\nerror ForbiddenTokenBalanceIncreasedException(address token);\n\n/// @notice Thrown when the remaining token balance is increased during the liquidation\nerror RemainingTokenBalanceIncreasedException(address token);\n\n/// @notice Thrown if `botMulticall` is called by an address that is not approved by account owner or is forbidden\nerror NotApprovedBotException(address bot);\n\n/// @notice Thrown when attempting to perform a multicall action with no permission for it\nerror NoPermissionException(uint256 permission);\n\n/// @notice Thrown when attempting to give a bot unexpected permissions\nerror UnexpectedPermissionsException(uint256 permissions);\n\n/// @notice Thrown when a custom HF parameter lower than 10000 is passed into the full collateral check\nerror CustomHealthFactorTooLowException();\n\n/// @notice Thrown when submitted collateral hint is not a valid token mask\nerror InvalidCollateralHintException(uint256 mask);\n\n/// @notice Thrown when trying to seize underlying token during partial liquidation\nerror UnderlyingIsNotLiquidatableException();\n\n/// @notice Thrown when amount of collateral seized during partial liquidation is less than required\nerror SeizedLessThanRequiredException(uint256 seizedAmount);\n\n// ------ //\n// ACCESS //\n// ------ //\n\n/// @notice Thrown on attempting to call an access restricted function not as credit account owner\nerror CallerNotCreditAccountOwnerException();\n\n/// @notice Thrown on attempting to call an access restricted function not as configurator\nerror CallerNotConfiguratorException();\n\n/// @notice Thrown on attempting to call an access-restructed function not as account factory\nerror CallerNotAccountFactoryException();\n\n/// @notice Thrown on attempting to call an access restricted function not as credit manager\nerror CallerNotCreditManagerException();\n\n/// @notice Thrown on attempting to call an access restricted function not as credit facade\nerror CallerNotCreditFacadeException();\n\n/// @notice Thrown on attempting to pause a contract without pausable admin rights\nerror CallerNotPausableAdminException();\n\n/// @notice Thrown on attempting to unpause a contract without unpausable admin rights\nerror CallerNotUnpausableAdminException();\n\n/// @notice Thrown on attempting to call an access restricted function not as gauge\nerror CallerNotGaugeException();\n\n/// @notice Thrown on attempting to call an access restricted function not as quota keeper\nerror CallerNotPoolQuotaKeeperException();\n\n/// @notice Thrown on attempting to call an access restricted function not as voter\nerror CallerNotVoterException();\n\n/// @notice Thrown on attempting to call an access restricted function not as allowed adapter\nerror CallerNotAdapterException();\n\n/// @notice Thrown on attempting to call an access restricted function not as migrator\nerror CallerNotMigratorException();\n\n/// @notice Thrown when an address that is not the designated executor attempts to execute a transaction\nerror CallerNotExecutorException();\n\n/// @notice Thrown on attempting to call an access restricted function not as veto admin\nerror CallerNotVetoAdminException();\n\n// -------- //\n// BOT LIST //\n// -------- //\n\n/// @notice Thrown when attempting to set non-zero permissions for a forbidden bot\nerror InvalidBotException();\n\n/// @notice Thrown when attempting to set permissions for a bot that don't meet its requirements\nerror IncorrectBotPermissionsException();\n\n/// @notice Thrown when attempting to set non-zero permissions for too many bots\nerror TooManyActiveBotsException();\n\n// --------------- //\n// ACCOUNT FACTORY //\n// --------------- //\n\n/// @notice Thrown when trying to deploy second master credit account for a credit manager\nerror MasterCreditAccountAlreadyDeployedException();\n\n/// @notice Thrown when trying to rescue funds from a credit account that is currently in use\nerror CreditAccountIsInUseException();\n\n// ------------ //\n// PRICE ORACLE //\n// ------------ //\n\n/// @notice Thrown on attempting to set a token price feed to an address that is not a correct price feed\nerror IncorrectPriceFeedException();\n\n/// @notice Thrown on attempting to interact with a price feed for a token not added to the price oracle\nerror PriceFeedDoesNotExistException();\n\n/// @notice Thrown when trying to apply an on-demand price update to a non-updatable price feed\nerror PriceFeedIsNotUpdatableException();\n\n/// @notice Thrown when price feed returns incorrect price for a token\nerror IncorrectPriceException();\n\n/// @notice Thrown when token's price feed becomes stale\nerror StalePriceException();\n","keccak256":"0x927791f51ce56069f31f5c04b675089ac5ff6e562402351a4e9404e52e9bcd51","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IACLTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IACLTrait {\n function acl() external view returns (address);\n}\n","keccak256":"0xa921b085fe58d074492944ec373dcf9e6f33b4a1e13b5d03f3eb37b64a23fd95","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegister.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IContractsRegister {\n function isPool(address) external view returns (bool);\n function getPools() external view returns (address[] memory);\n function isCreditManager(address) external view returns (bool);\n function getCreditManagers() external view returns (address[] memory);\n}\n","keccak256":"0xbfea2a5497975edec84670da12d09f3a87711faae3edeb1af5cb5a3325b50924","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IPriceFeedStore.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IVersion} from \"./IVersion.sol\";\n\nstruct PriceUpdate {\n address priceFeed;\n bytes data;\n}\n\ninterface IPriceFeedStore {\n function getStalenessPeriod(address priceFeed) external view returns (uint32);\n function updatePrices(PriceUpdate[] calldata updates) external;\n}\n","keccak256":"0x7b63a18afbeaa37d11d7e1623898225802b4d22e43c932328b27b9646aaf44c7","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\n/// @title Version interface\n/// @notice Defines contract version and type\ninterface IVersion {\n /// @notice Contract version\n function version() external view returns (uint256);\n\n /// @notice Contract type\n function contractType() external view returns (bytes32);\n}\n","keccak256":"0x985c0de4e24e431747820560798af3492989dba02e654e8cf4b006f2eedfc42c","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/libraries/BalancesLogic.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {SafeCast} from \"@openzeppelin/contracts/utils/math/SafeCast.sol\";\nimport {SafeERC20} from \"@1inch/solidity-utils/contracts/libraries/SafeERC20.sol\";\n\nimport {BitMask} from \"./BitMask.sol\";\n\nstruct Balance {\n address token;\n uint256 balance;\n}\n\nstruct BalanceWithMask {\n address token;\n uint256 tokenMask;\n uint256 balance;\n}\n\nstruct BalanceDelta {\n address token;\n int256 amount;\n}\n\nenum Comparison {\n GREATER_OR_EQUAL,\n LESS_OR_EQUAL\n}\n\n/// @title Balances logic library\n/// @notice Implements functions for before-and-after balance comparisons\nlibrary BalancesLogic {\n using BitMask for uint256;\n using SafeCast for int256;\n using SafeCast for uint256;\n using SafeERC20 for IERC20;\n\n /// @dev Compares current `token` balance with `value`\n /// @param token Token to check balance for\n /// @param value Value to compare current token balance with\n /// @param comparison Whether current balance must be greater/less than or equal to `value`\n function checkBalance(address creditAccount, address token, uint256 value, Comparison comparison)\n internal\n view\n returns (bool)\n {\n uint256 current = IERC20(token).safeBalanceOf(creditAccount);\n return (comparison == Comparison.GREATER_OR_EQUAL && current >= value)\n || (comparison == Comparison.LESS_OR_EQUAL && current <= value); // U:[BLL-1]\n }\n\n /// @dev Returns an array of expected token balances after operations\n /// @param creditAccount Credit account to compute balances for\n /// @param deltas Array of expected token balance changes\n function storeBalances(address creditAccount, BalanceDelta[] memory deltas)\n internal\n view\n returns (Balance[] memory balances)\n {\n uint256 len = deltas.length;\n balances = new Balance[](len); // U:[BLL-2]\n for (uint256 i = 0; i < len;) {\n int256 balance = IERC20(deltas[i].token).safeBalanceOf(creditAccount).toInt256();\n balances[i] = Balance({token: deltas[i].token, balance: (balance + deltas[i].amount).toUint256()}); // U:[BLL-2]\n unchecked {\n ++i;\n }\n }\n }\n\n /// @dev Compares current balances with the previously stored ones\n /// @param creditAccount Credit account to compare balances for\n /// @param balances Array of previously stored balances\n /// @param comparison Whether current balances must be greater/less than or equal to stored ones\n /// @return failedToken The first token for which the condition specified by `comparison` fails, if any\n function compareBalances(address creditAccount, Balance[] memory balances, Comparison comparison)\n internal\n view\n returns (address failedToken)\n {\n unchecked {\n uint256 len = balances.length;\n for (uint256 i; i < len; ++i) {\n if (!BalancesLogic.checkBalance(creditAccount, balances[i].token, balances[i].balance, comparison)) {\n return balances[i].token; // U:[BLL-3]\n }\n }\n }\n }\n\n /// @dev Returns balances of specified tokens on the credit account\n /// @param creditAccount Credit account to compute balances for\n /// @param tokensMask Bit mask of tokens to compute balances for\n /// @param getTokenByMaskFn Function that returns token's address by its mask\n function storeBalances(\n address creditAccount,\n uint256 tokensMask,\n function (uint256) view returns (address) getTokenByMaskFn\n ) internal view returns (BalanceWithMask[] memory balances) {\n if (tokensMask == 0) return balances;\n\n balances = new BalanceWithMask[](tokensMask.calcEnabledTokens()); // U:[BLL-4]\n unchecked {\n uint256 i;\n while (tokensMask != 0) {\n uint256 tokenMask = tokensMask.lsbMask();\n tokensMask ^= tokenMask;\n\n address token = getTokenByMaskFn(tokenMask);\n balances[i] = BalanceWithMask({\n token: token,\n tokenMask: tokenMask,\n balance: IERC20(token).safeBalanceOf(creditAccount)\n }); // U:[BLL-4]\n ++i;\n }\n }\n }\n\n /// @dev Compares current balances of specified tokens with the previously stored ones\n /// @param creditAccount Credit account to compare balances for\n /// @param tokensMask Bit mask of tokens to compare balances for\n /// @param balances Array of previously stored balances\n /// @param comparison Whether current balances must be greater/less than or equal to stored ones\n /// @return failedToken The first token for which the condition specified by `comparison` fails, if any\n /// @dev This function assumes that `tokensMask` encodes a subset of tokens from `balances`\n function compareBalances(\n address creditAccount,\n uint256 tokensMask,\n BalanceWithMask[] memory balances,\n Comparison comparison\n ) internal view returns (address failedToken) {\n if (tokensMask == 0) return address(0);\n\n unchecked {\n uint256 len = balances.length;\n for (uint256 i; i < len; ++i) {\n if (tokensMask & balances[i].tokenMask == 0) continue;\n if (!BalancesLogic.checkBalance(creditAccount, balances[i].token, balances[i].balance, comparison)) {\n return balances[i].token; // U:[BLL-5]\n }\n }\n }\n }\n}\n","keccak256":"0x70e639e3937f8e1658ea4f3d2d7a48c5886602182318533ba521d876fa2df11d","license":"BUSL-1.1"},"lib/@gearbox-protocol/core-v3/contracts/libraries/BitMask.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IncorrectParameterException} from \"../interfaces/IExceptions.sol\";\n\n/// @title Bit mask library\n/// @notice Implements functions that manipulate bit masks\n/// Bit masks are utilized extensively by Gearbox to efficiently store token sets (enabled tokens on accounts\n/// or forbidden tokens) and check for set inclusion. A mask is a uint256 number that has its i-th bit set to\n/// 1 if i-th item is included into the set. For example, each token has a mask equal to 2**i, so set inclusion\n/// can be checked by checking tokenMask & setMask != 0.\nlibrary BitMask {\n /// @dev Calculates the number of `1` bits\n /// @param enabledTokensMask Bit mask to compute the number of `1` bits in\n function calcEnabledTokens(uint256 enabledTokensMask) internal pure returns (uint256 totalTokensEnabled) {\n unchecked {\n while (enabledTokensMask > 0) {\n enabledTokensMask &= enabledTokensMask - 1; // U:[BM-3]\n ++totalTokensEnabled; // U:[BM-3]\n }\n }\n }\n\n /// @dev Enables bits from the second mask in the first mask\n /// @param enabledTokenMask The initial mask\n /// @param bitsToEnable Mask of bits to enable\n function enable(uint256 enabledTokenMask, uint256 bitsToEnable) internal pure returns (uint256) {\n return enabledTokenMask | bitsToEnable; // U:[BM-4]\n }\n\n /// @dev Disables bits from the second mask in the first mask\n /// @param enabledTokenMask The initial mask\n /// @param bitsToDisable Mask of bits to disable\n function disable(uint256 enabledTokenMask, uint256 bitsToDisable) internal pure returns (uint256) {\n return enabledTokenMask & ~bitsToDisable; // U:[BM-4]\n }\n\n /// @dev Computes a new mask with sets of new enabled and disabled bits\n /// @dev bitsToEnable and bitsToDisable are applied sequentially to original mask\n /// @param enabledTokensMask The initial mask\n /// @param bitsToEnable Mask with bits to enable\n /// @param bitsToDisable Mask with bits to disable\n function enableDisable(uint256 enabledTokensMask, uint256 bitsToEnable, uint256 bitsToDisable)\n internal\n pure\n returns (uint256)\n {\n return (enabledTokensMask | bitsToEnable) & (~bitsToDisable); // U:[BM-5]\n }\n\n /// @dev Returns a mask with only the least significant bit of `mask` enabled\n /// @dev This function can be used to efficiently iterate over enabled bits in a mask\n function lsbMask(uint256 mask) internal pure returns (uint256) {\n unchecked {\n return mask & uint256(-int256(mask)); // U:[BM-6]\n }\n }\n}\n","keccak256":"0x31a08ce3f34714d16779243ab779d77dff877611e072e80dc61e891d9d9bb0c2","license":"BUSL-1.1"},"lib/@gearbox-protocol/core-v3/contracts/libraries/Constants.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nbytes32 constant AP_GEAR_TOKEN = \"GLOBAL::GEAR_TOKEN\";\nbytes32 constant AP_INSTANCE_MANAGER_PROXY = \"INSTANCE_MANAGER_PROXY\";\nbytes32 constant AP_CROSS_CHAIN_GOVERNANCE_PROXY = \"CROSS_CHAIN_GOVERNANCE_PROXY\";\nbytes32 constant AP_PRICE_FEED_STORE = \"PRICE_FEED_STORE\";\nuint256 constant NO_VERSION_CONTROL = 0;\n\nuint256 constant WAD = 1e18;\nuint256 constant RAY = 1e27;\nuint16 constant PERCENTAGE_FACTOR = 1e4;\n\nuint256 constant SECONDS_PER_YEAR = 365 days;\nuint256 constant EPOCH_LENGTH = 7 days;\nuint256 constant FIRST_EPOCH_TIMESTAMP = 1702900800;\nuint256 constant EPOCHS_TO_WITHDRAW = 4;\n\nuint8 constant MAX_SANE_ENABLED_TOKENS = 20;\nuint256 constant MAX_SANE_EPOCH_LENGTH = 28 days;\nuint256 constant MAX_SANE_ACTIVE_BOTS = 5;\n\nuint8 constant MAX_WITHDRAW_FEE = 100;\n\nuint8 constant DEFAULT_LIMIT_PER_BLOCK_MULTIPLIER = 2;\n\nuint8 constant BOT_PERMISSIONS_SET_FLAG = 1;\n\nuint256 constant UNDERLYING_TOKEN_MASK = 1;\n\naddress constant INACTIVE_CREDIT_ACCOUNT_ADDRESS = address(1);\n","keccak256":"0x54723ebc12d90e0ba743d252ce7b951dcf7e8f437b6a3093746c0af71cbdc5b4","license":"BUSL-1.1"},"lib/@gearbox-protocol/core-v3/contracts/traits/SanityCheckTrait.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {ZeroAddressException} from \"../interfaces/IExceptions.sol\";\n\n/// @title Sanity check trait\nabstract contract SanityCheckTrait {\n /// @dev Ensures that passed address is non-zero\n modifier nonZeroAddress(address addr) {\n _revertIfZeroAddress(addr);\n _;\n }\n\n /// @dev Reverts if address is zero\n function _revertIfZeroAddress(address addr) private pure {\n if (addr == address(0)) revert ZeroAddressException();\n }\n}\n","keccak256":"0x1c620faa712948ece4c1f7a1b3242c382270f1db84549176e19309733c0b60fd","license":"BUSL-1.1"},"lib/@gearbox-protocol/permissionless/contracts/interfaces/IContractsRegister.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IACLTrait} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IACLTrait.sol\";\nimport {IContractsRegister as IContractsRegisterBase} from\n \"@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegister.sol\";\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\n\ninterface IContractsRegister is IContractsRegisterBase, IVersion, IACLTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event RegisterMarket(address indexed pool, address indexed priceOracle, address indexed lossPolicy);\n event ShutdownMarket(address indexed pool);\n event RegisterCreditSuite(address indexed pool, address indexed creditManager);\n event ShutdownCreditSuite(address indexed pool, address indexed creditManager);\n event SetPriceOracle(address indexed pool, address indexed priceOracle);\n event SetLossPolicy(address indexed pool, address indexed lossPolicy);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error MarketNotRegisteredException(address pool);\n error MarketShutDownException(address pool);\n error MarketNotEmptyException(address pool);\n error CreditSuiteNotRegisteredException(address creditManager);\n error CreditSuiteShutDownException(address creditManager);\n\n // ------- //\n // MARKETS //\n // ------- //\n\n function getShutdownPools() external view returns (address[] memory);\n function getPriceOracle(address pool) external view returns (address);\n function getLossPolicy(address pool) external view returns (address);\n\n function registerMarket(address pool, address priceOracle, address lossPolicy) external;\n function shutdownMarket(address pool) external;\n function setPriceOracle(address pool, address priceOracle) external;\n function setLossPolicy(address pool, address lossPolicy) external;\n\n // ------------- //\n // CREDIT SUITES //\n // ------------- //\n\n function getCreditManagers(address pool) external view returns (address[] memory);\n function getShutdownCreditManagers() external view returns (address[] memory);\n function getShutdownCreditManagers(address pool) external view returns (address[] memory);\n\n function registerCreditSuite(address creditManager) external;\n function shutdownCreditSuite(address creditManager) external;\n}\n","keccak256":"0xc8f2c626169e54517e2912a528c0d560c865e938db718995af483fae31cb82b2","license":"MIT"},"lib/@gearbox-protocol/permissionless/contracts/interfaces/IMarketConfigurator.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IDeployerTrait} from \"./base/IDeployerTrait.sol\";\nimport {Call, DeployParams, MarketFactories} from \"./Types.sol\";\n\ninterface IMarketConfigurator is IVersion, IDeployerTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event SetEmergencyAdmin(address indexed newEmergencyAdmin);\n\n event GrantRole(bytes32 indexed role, address indexed account);\n\n event RevokeRole(bytes32 indexed role, address indexed account);\n\n event EmergencyRevokeRole(bytes32 indexed role, address indexed account);\n\n event CreateMarket(\n address indexed pool,\n address priceOracle,\n address interestRateModel,\n address rateKeeper,\n address lossPolicy,\n MarketFactories factories\n );\n\n event ShutdownMarket(address indexed pool);\n\n event AddToken(address indexed pool, address indexed token);\n\n event ConfigurePool(address indexed pool, bytes data);\n\n event EmergencyConfigurePool(address indexed pool, bytes data);\n\n event CreateCreditSuite(address indexed creditManager, address factory);\n\n event ShutdownCreditSuite(address indexed creditManager);\n\n event ConfigureCreditSuite(address indexed creditManager, bytes data);\n\n event EmergencyConfigureCreditSuite(address indexed creditManager, bytes data);\n\n event UpdatePriceOracle(address indexed pool, address priceOracle);\n\n event ConfigurePriceOracle(address indexed pool, bytes data);\n\n event EmergencyConfigurePriceOracle(address indexed pool, bytes data);\n\n event UpdateInterestRateModel(address indexed pool, address interestRateModel);\n\n event ConfigureInterestRateModel(address indexed pool, bytes data);\n\n event EmergencyConfigureInterestRateModel(address indexed pool, bytes data);\n\n event UpdateRateKeeper(address indexed pool, address rateKeeper);\n\n event ConfigureRateKeeper(address indexed pool, bytes data);\n\n event EmergencyConfigureRateKeeper(address indexed pool, bytes data);\n\n event UpdateLossPolicy(address indexed pool, address lossPolicy);\n\n event ConfigureLossPolicy(address indexed pool, bytes data);\n\n event EmergencyConfigureLossPolicy(address indexed pool, bytes data);\n\n event AddPeripheryContract(bytes32 indexed domain, address indexed peripheryContract);\n\n event RemovePeripheryContract(bytes32 indexed domain, address indexed peripheryContract);\n\n event AuthorizeFactory(address indexed factory, address indexed suite, address indexed target);\n\n event UnauthorizeFactory(address indexed factory, address indexed suite, address indexed target);\n\n event UpgradePoolFactory(address indexed pool, address factory);\n\n event UpgradePriceOracleFactory(address indexed pool, address factory);\n\n event UpgradeInterestRateModelFactory(address indexed pool, address factory);\n\n event UpgradeRateKeeperFactory(address indexed pool, address factory);\n\n event UpgradeLossPolicyFactory(address indexed pool, address factory);\n\n event UpgradeCreditFactory(address indexed creditManager, address factory);\n\n event ExecuteHook(address indexed target, bytes callData);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error CallerIsNotAdminException(address caller);\n\n error CallerIsNotEmergencyAdminException(address caller);\n\n error CallerIsNotSelfException(address caller);\n\n error CreditSuiteNotRegisteredException(address creditManager);\n\n error IncorrectMinorVersionException(uint256 version);\n\n error IncorrectPeripheryContractException(address peripheryContract);\n\n error MarketNotRegisteredException(address pool);\n\n error UnauthorizedFactoryException(address factory, address target);\n\n // --------------- //\n // STATE VARIABLES //\n // --------------- //\n\n function admin() external view returns (address);\n function emergencyAdmin() external view returns (address);\n function curatorName() external view returns (string memory);\n\n function acl() external view returns (address);\n function contractsRegister() external view returns (address);\n function treasury() external view returns (address);\n\n // ---------------- //\n // ROLES MANAGEMENT //\n // ---------------- //\n\n function setEmergencyAdmin(address newEmergencyAdmin) external;\n\n function grantRole(bytes32 role, address account) external;\n\n function revokeRole(bytes32 role, address account) external;\n\n function emergencyRevokeRole(bytes32 role, address account) external;\n\n // ----------------- //\n // MARKET MANAGEMENT //\n // ----------------- //\n\n function previewCreateMarket(uint256 minorVersion, address underlying, string calldata name, string calldata symbol)\n external\n view\n returns (address pool);\n\n function createMarket(\n uint256 minorVersion,\n address underlying,\n string calldata name,\n string calldata symbol,\n DeployParams calldata interestRateModelParams,\n DeployParams calldata rateKeeperParams,\n DeployParams calldata lossPolicyParams,\n address underlyingPriceFeed\n ) external returns (address pool);\n\n function shutdownMarket(address pool) external;\n\n function addToken(address pool, address token, address priceFeed) external;\n\n function configurePool(address pool, bytes calldata data) external;\n\n function emergencyConfigurePool(address pool, bytes calldata data) external;\n\n // ----------------------- //\n // CREDIT SUITE MANAGEMENT //\n // ----------------------- //\n\n function previewCreateCreditSuite(uint256 minorVersion, address pool, bytes calldata encodedParams)\n external\n view\n returns (address creditManager);\n\n function previewCreateCreditSuite(\n uint256 marketMinorVersion,\n uint256 creditSuiteMinorVersion,\n address underlying,\n string calldata name,\n string calldata symbol,\n bytes calldata encodedParams\n ) external view returns (address creditManager);\n\n function createCreditSuite(uint256 minorVersion, address pool, bytes calldata encdodedParams)\n external\n returns (address creditManager);\n\n function shutdownCreditSuite(address creditManager) external;\n\n function configureCreditSuite(address creditManager, bytes calldata data) external;\n\n function emergencyConfigureCreditSuite(address creditManager, bytes calldata data) external;\n\n // ----------------------- //\n // PRICE ORACLE MANAGEMENT //\n // ----------------------- //\n\n function updatePriceOracle(address pool) external returns (address priceOracle);\n\n function configurePriceOracle(address pool, bytes calldata data) external;\n\n function emergencyConfigurePriceOracle(address pool, bytes calldata data) external;\n\n // -------------- //\n // IRM MANAGEMENT //\n // -------------- //\n\n function updateInterestRateModel(address pool, DeployParams calldata params) external returns (address irm);\n\n function configureInterestRateModel(address pool, bytes calldata data) external;\n\n function emergencyConfigureInterestRateModel(address pool, bytes calldata data) external;\n\n // ---------------------- //\n // RATE KEEPER MANAGEMENT //\n // ---------------------- //\n\n function updateRateKeeper(address pool, DeployParams calldata params) external returns (address rateKeeper);\n\n function configureRateKeeper(address pool, bytes calldata data) external;\n\n function emergencyConfigureRateKeeper(address pool, bytes calldata data) external;\n\n // -\u2013-------------------- //\n // LOSS POLICY MANAGEMENT //\n // -\u2013-------------------- //\n\n function updateLossPolicy(address pool, DeployParams calldata params) external returns (address lossPolicy);\n\n function configureLossPolicy(address pool, bytes calldata data) external;\n\n function emergencyConfigureLossPolicy(address pool, bytes calldata data) external;\n\n // --------- //\n // PERIPHERY //\n // --------- //\n\n function getPeripheryContracts(bytes32 domain) external view returns (address[] memory);\n\n function isPeripheryContract(bytes32 domain, address peripheryContract) external view returns (bool);\n\n function addPeripheryContract(address peripheryContract) external;\n\n function removePeripheryContract(address peripheryContract) external;\n\n // --------- //\n // FACTORIES //\n // --------- //\n\n function getMarketFactories(address pool) external view returns (MarketFactories memory);\n\n function getCreditFactory(address creditManager) external view returns (address);\n\n function getAuthorizedFactory(address target) external view returns (address);\n\n function getFactoryTargets(address factory, address suite) external view returns (address[] memory);\n\n function authorizeFactory(address factory, address suite, address target) external;\n\n function unauthorizeFactory(address factory, address suite, address target) external;\n\n function upgradePoolFactory(address pool) external;\n\n function upgradePriceOracleFactory(address pool) external;\n\n function upgradeInterestRateModelFactory(address pool) external;\n\n function upgradeRateKeeperFactory(address pool) external;\n\n function upgradeLossPolicyFactory(address pool) external;\n\n function upgradeCreditFactory(address creditManager) external;\n}\n","keccak256":"0x7f5f689da9baa93c6cca8b2e3ca40ce2c255299952454834c54dd055ba7dc3c4","license":"MIT"},"lib/@gearbox-protocol/permissionless/contracts/interfaces/Types.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nstruct AddressProviderEntry {\n bytes32 key;\n uint256 ver;\n address value;\n}\n\nstruct AuditReport {\n address auditor;\n string reportUrl;\n bytes signature;\n}\n\nstruct Bytecode {\n bytes32 contractType;\n uint256 version;\n bytes initCode;\n address author;\n string source;\n bytes authorSignature;\n}\n\nstruct BytecodePointer {\n bytes32 contractType;\n uint256 version;\n address[] initCodePointers;\n address author;\n string source;\n bytes authorSignature;\n}\n\nstruct Call {\n address target;\n bytes callData;\n}\n\nstruct ConnectedPriceFeed {\n address token;\n address[] priceFeeds;\n}\n\nstruct CrossChainCall {\n uint256 chainId; // 0 means to be executed on all chains\n address target;\n bytes callData;\n}\n\nstruct DeployParams {\n bytes32 postfix;\n bytes32 salt;\n bytes constructorParams;\n}\n\nstruct DeployResult {\n address newContract;\n Call[] onInstallOps;\n}\n\nstruct MarketFactories {\n address poolFactory;\n address priceOracleFactory;\n address interestRateModelFactory;\n address rateKeeperFactory;\n address lossPolicyFactory;\n}\n\nstruct PriceFeedInfo {\n string name;\n uint32 stalenessPeriod;\n bytes32 priceFeedType;\n uint256 version;\n}\n\nstruct SignedBatch {\n string name;\n bytes32 prevHash;\n CrossChainCall[] calls;\n bytes[] signatures;\n}\n\nstruct SignedRecoveryModeMessage {\n uint256 chainId;\n bytes32 startingBatchHash;\n bytes[] signatures;\n}\n\nstruct Split {\n bool initialized;\n address[] receivers;\n uint16[] proportions;\n}\n\nstruct TwoAdminProposal {\n bytes callData;\n bool confirmedByAdmin;\n bool confirmedByTreasuryProxy;\n}\n","keccak256":"0x6ac5744449d420d240bf0e9e61d61179258f96fab460d37baace204c4c065c84","license":"MIT"},"lib/@gearbox-protocol/permissionless/contracts/interfaces/base/IDeployerTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\n/// @title Deployer trait interface\ninterface IDeployerTrait {\n function addressProvider() external view returns (address);\n\n function bytecodeRepository() external view returns (address);\n}\n","keccak256":"0xef8f1291807bb65f6f5a622040e5fd293a01b8497e577957ab7ed913ed011273","license":"MIT"},"lib/@openzeppelin/contracts/interfaces/IERC4626.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4626.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../token/ERC20/IERC20.sol\";\nimport \"../token/ERC20/extensions/IERC20Metadata.sol\";\n\n/**\n * @dev Interface of the ERC4626 \"Tokenized Vault Standard\", as defined in\n * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].\n *\n * _Available since v4.7._\n */\ninterface IERC4626 is IERC20, IERC20Metadata {\n event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);\n\n event Withdraw(\n address indexed sender,\n address indexed receiver,\n address indexed owner,\n uint256 assets,\n uint256 shares\n );\n\n /**\n * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\n *\n * - MUST be an ERC-20 token contract.\n * - MUST NOT revert.\n */\n function asset() external view returns (address assetTokenAddress);\n\n /**\n * @dev Returns the total amount of the underlying asset that is \u201cmanaged\u201d by Vault.\n *\n * - SHOULD include any compounding that occurs from yield.\n * - MUST be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT revert.\n */\n function totalAssets() external view returns (uint256 totalManagedAssets);\n\n /**\n * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the \u201cper-user\u201d price-per-share, and instead should reflect the\n * \u201caverage-user\u2019s\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToShares(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the \u201cper-user\u201d price-per-share, and instead should reflect the\n * \u201caverage-user\u2019s\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToAssets(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\n * through a deposit call.\n *\n * - MUST return a limited value if receiver is subject to some deposit limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\n * - MUST NOT revert.\n */\n function maxDeposit(address receiver) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\n * call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\n * in the same transaction.\n * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\n * deposit would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewDeposit(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * deposit execution, and are accounted for during deposit.\n * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault\u2019s underlying asset token.\n */\n function deposit(uint256 assets, address receiver) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\n * - MUST return a limited value if receiver is subject to some mint limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\n * - MUST NOT revert.\n */\n function maxMint(address receiver) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\n * in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\n * same transaction.\n * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\n * would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by minting.\n */\n function previewMint(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\n * execution, and are accounted for during mint.\n * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault\u2019s underlying asset token.\n */\n function mint(uint256 shares, address receiver) external returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\n * Vault, through a withdraw call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxWithdraw(address owner) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\n * call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\n * called\n * in the same transaction.\n * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\n * the withdrawal would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewWithdraw(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * withdraw execution, and are accounted for during withdraw.\n * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\n * through a redeem call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxRedeem(address owner) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\n * in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\n * same transaction.\n * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\n * redemption would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\n */\n function previewRedeem(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * redeem execution, and are accounted for during redeem.\n * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\n}\n","keccak256":"0x5a173dcd1c1f0074e4df6a9cdab3257e17f2e64f7b8f30ca9e17a8c5ea250e1c","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\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 amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` 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 amount) external returns (bool);\n}\n","keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\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","keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n","keccak256":"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/draft-IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n// EIP-2612 is Final as of 2022-11-01. This file is deprecated.\n\nimport \"./IERC20Permit.sol\";\n","keccak256":"0xc7134e0f63b0adcee02bf4b15efb2d0d4b1c03ae0d127dc90d846da4cab23a76","license":"MIT"},"lib/@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n /**\n * @dev Returns the downcasted uint248 from uint256, reverting on\n * overflow (when the input is greater than largest uint248).\n *\n * Counterpart to Solidity's `uint248` operator.\n *\n * Requirements:\n *\n * - input must fit into 248 bits\n *\n * _Available since v4.7._\n */\n function toUint248(uint256 value) internal pure returns (uint248) {\n require(value <= type(uint248).max, \"SafeCast: value doesn't fit in 248 bits\");\n return uint248(value);\n }\n\n /**\n * @dev Returns the downcasted uint240 from uint256, reverting on\n * overflow (when the input is greater than largest uint240).\n *\n * Counterpart to Solidity's `uint240` operator.\n *\n * Requirements:\n *\n * - input must fit into 240 bits\n *\n * _Available since v4.7._\n */\n function toUint240(uint256 value) internal pure returns (uint240) {\n require(value <= type(uint240).max, \"SafeCast: value doesn't fit in 240 bits\");\n return uint240(value);\n }\n\n /**\n * @dev Returns the downcasted uint232 from uint256, reverting on\n * overflow (when the input is greater than largest uint232).\n *\n * Counterpart to Solidity's `uint232` operator.\n *\n * Requirements:\n *\n * - input must fit into 232 bits\n *\n * _Available since v4.7._\n */\n function toUint232(uint256 value) internal pure returns (uint232) {\n require(value <= type(uint232).max, \"SafeCast: value doesn't fit in 232 bits\");\n return uint232(value);\n }\n\n /**\n * @dev Returns the downcasted uint224 from uint256, reverting on\n * overflow (when the input is greater than largest uint224).\n *\n * Counterpart to Solidity's `uint224` operator.\n *\n * Requirements:\n *\n * - input must fit into 224 bits\n *\n * _Available since v4.2._\n */\n function toUint224(uint256 value) internal pure returns (uint224) {\n require(value <= type(uint224).max, \"SafeCast: value doesn't fit in 224 bits\");\n return uint224(value);\n }\n\n /**\n * @dev Returns the downcasted uint216 from uint256, reverting on\n * overflow (when the input is greater than largest uint216).\n *\n * Counterpart to Solidity's `uint216` operator.\n *\n * Requirements:\n *\n * - input must fit into 216 bits\n *\n * _Available since v4.7._\n */\n function toUint216(uint256 value) internal pure returns (uint216) {\n require(value <= type(uint216).max, \"SafeCast: value doesn't fit in 216 bits\");\n return uint216(value);\n }\n\n /**\n * @dev Returns the downcasted uint208 from uint256, reverting on\n * overflow (when the input is greater than largest uint208).\n *\n * Counterpart to Solidity's `uint208` operator.\n *\n * Requirements:\n *\n * - input must fit into 208 bits\n *\n * _Available since v4.7._\n */\n function toUint208(uint256 value) internal pure returns (uint208) {\n require(value <= type(uint208).max, \"SafeCast: value doesn't fit in 208 bits\");\n return uint208(value);\n }\n\n /**\n * @dev Returns the downcasted uint200 from uint256, reverting on\n * overflow (when the input is greater than largest uint200).\n *\n * Counterpart to Solidity's `uint200` operator.\n *\n * Requirements:\n *\n * - input must fit into 200 bits\n *\n * _Available since v4.7._\n */\n function toUint200(uint256 value) internal pure returns (uint200) {\n require(value <= type(uint200).max, \"SafeCast: value doesn't fit in 200 bits\");\n return uint200(value);\n }\n\n /**\n * @dev Returns the downcasted uint192 from uint256, reverting on\n * overflow (when the input is greater than largest uint192).\n *\n * Counterpart to Solidity's `uint192` operator.\n *\n * Requirements:\n *\n * - input must fit into 192 bits\n *\n * _Available since v4.7._\n */\n function toUint192(uint256 value) internal pure returns (uint192) {\n require(value <= type(uint192).max, \"SafeCast: value doesn't fit in 192 bits\");\n return uint192(value);\n }\n\n /**\n * @dev Returns the downcasted uint184 from uint256, reverting on\n * overflow (when the input is greater than largest uint184).\n *\n * Counterpart to Solidity's `uint184` operator.\n *\n * Requirements:\n *\n * - input must fit into 184 bits\n *\n * _Available since v4.7._\n */\n function toUint184(uint256 value) internal pure returns (uint184) {\n require(value <= type(uint184).max, \"SafeCast: value doesn't fit in 184 bits\");\n return uint184(value);\n }\n\n /**\n * @dev Returns the downcasted uint176 from uint256, reverting on\n * overflow (when the input is greater than largest uint176).\n *\n * Counterpart to Solidity's `uint176` operator.\n *\n * Requirements:\n *\n * - input must fit into 176 bits\n *\n * _Available since v4.7._\n */\n function toUint176(uint256 value) internal pure returns (uint176) {\n require(value <= type(uint176).max, \"SafeCast: value doesn't fit in 176 bits\");\n return uint176(value);\n }\n\n /**\n * @dev Returns the downcasted uint168 from uint256, reverting on\n * overflow (when the input is greater than largest uint168).\n *\n * Counterpart to Solidity's `uint168` operator.\n *\n * Requirements:\n *\n * - input must fit into 168 bits\n *\n * _Available since v4.7._\n */\n function toUint168(uint256 value) internal pure returns (uint168) {\n require(value <= type(uint168).max, \"SafeCast: value doesn't fit in 168 bits\");\n return uint168(value);\n }\n\n /**\n * @dev Returns the downcasted uint160 from uint256, reverting on\n * overflow (when the input is greater than largest uint160).\n *\n * Counterpart to Solidity's `uint160` operator.\n *\n * Requirements:\n *\n * - input must fit into 160 bits\n *\n * _Available since v4.7._\n */\n function toUint160(uint256 value) internal pure returns (uint160) {\n require(value <= type(uint160).max, \"SafeCast: value doesn't fit in 160 bits\");\n return uint160(value);\n }\n\n /**\n * @dev Returns the downcasted uint152 from uint256, reverting on\n * overflow (when the input is greater than largest uint152).\n *\n * Counterpart to Solidity's `uint152` operator.\n *\n * Requirements:\n *\n * - input must fit into 152 bits\n *\n * _Available since v4.7._\n */\n function toUint152(uint256 value) internal pure returns (uint152) {\n require(value <= type(uint152).max, \"SafeCast: value doesn't fit in 152 bits\");\n return uint152(value);\n }\n\n /**\n * @dev Returns the downcasted uint144 from uint256, reverting on\n * overflow (when the input is greater than largest uint144).\n *\n * Counterpart to Solidity's `uint144` operator.\n *\n * Requirements:\n *\n * - input must fit into 144 bits\n *\n * _Available since v4.7._\n */\n function toUint144(uint256 value) internal pure returns (uint144) {\n require(value <= type(uint144).max, \"SafeCast: value doesn't fit in 144 bits\");\n return uint144(value);\n }\n\n /**\n * @dev Returns the downcasted uint136 from uint256, reverting on\n * overflow (when the input is greater than largest uint136).\n *\n * Counterpart to Solidity's `uint136` operator.\n *\n * Requirements:\n *\n * - input must fit into 136 bits\n *\n * _Available since v4.7._\n */\n function toUint136(uint256 value) internal pure returns (uint136) {\n require(value <= type(uint136).max, \"SafeCast: value doesn't fit in 136 bits\");\n return uint136(value);\n }\n\n /**\n * @dev Returns the downcasted uint128 from uint256, reverting on\n * overflow (when the input is greater than largest uint128).\n *\n * Counterpart to Solidity's `uint128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n *\n * _Available since v2.5._\n */\n function toUint128(uint256 value) internal pure returns (uint128) {\n require(value <= type(uint128).max, \"SafeCast: value doesn't fit in 128 bits\");\n return uint128(value);\n }\n\n /**\n * @dev Returns the downcasted uint120 from uint256, reverting on\n * overflow (when the input is greater than largest uint120).\n *\n * Counterpart to Solidity's `uint120` operator.\n *\n * Requirements:\n *\n * - input must fit into 120 bits\n *\n * _Available since v4.7._\n */\n function toUint120(uint256 value) internal pure returns (uint120) {\n require(value <= type(uint120).max, \"SafeCast: value doesn't fit in 120 bits\");\n return uint120(value);\n }\n\n /**\n * @dev Returns the downcasted uint112 from uint256, reverting on\n * overflow (when the input is greater than largest uint112).\n *\n * Counterpart to Solidity's `uint112` operator.\n *\n * Requirements:\n *\n * - input must fit into 112 bits\n *\n * _Available since v4.7._\n */\n function toUint112(uint256 value) internal pure returns (uint112) {\n require(value <= type(uint112).max, \"SafeCast: value doesn't fit in 112 bits\");\n return uint112(value);\n }\n\n /**\n * @dev Returns the downcasted uint104 from uint256, reverting on\n * overflow (when the input is greater than largest uint104).\n *\n * Counterpart to Solidity's `uint104` operator.\n *\n * Requirements:\n *\n * - input must fit into 104 bits\n *\n * _Available since v4.7._\n */\n function toUint104(uint256 value) internal pure returns (uint104) {\n require(value <= type(uint104).max, \"SafeCast: value doesn't fit in 104 bits\");\n return uint104(value);\n }\n\n /**\n * @dev Returns the downcasted uint96 from uint256, reverting on\n * overflow (when the input is greater than largest uint96).\n *\n * Counterpart to Solidity's `uint96` operator.\n *\n * Requirements:\n *\n * - input must fit into 96 bits\n *\n * _Available since v4.2._\n */\n function toUint96(uint256 value) internal pure returns (uint96) {\n require(value <= type(uint96).max, \"SafeCast: value doesn't fit in 96 bits\");\n return uint96(value);\n }\n\n /**\n * @dev Returns the downcasted uint88 from uint256, reverting on\n * overflow (when the input is greater than largest uint88).\n *\n * Counterpart to Solidity's `uint88` operator.\n *\n * Requirements:\n *\n * - input must fit into 88 bits\n *\n * _Available since v4.7._\n */\n function toUint88(uint256 value) internal pure returns (uint88) {\n require(value <= type(uint88).max, \"SafeCast: value doesn't fit in 88 bits\");\n return uint88(value);\n }\n\n /**\n * @dev Returns the downcasted uint80 from uint256, reverting on\n * overflow (when the input is greater than largest uint80).\n *\n * Counterpart to Solidity's `uint80` operator.\n *\n * Requirements:\n *\n * - input must fit into 80 bits\n *\n * _Available since v4.7._\n */\n function toUint80(uint256 value) internal pure returns (uint80) {\n require(value <= type(uint80).max, \"SafeCast: value doesn't fit in 80 bits\");\n return uint80(value);\n }\n\n /**\n * @dev Returns the downcasted uint72 from uint256, reverting on\n * overflow (when the input is greater than largest uint72).\n *\n * Counterpart to Solidity's `uint72` operator.\n *\n * Requirements:\n *\n * - input must fit into 72 bits\n *\n * _Available since v4.7._\n */\n function toUint72(uint256 value) internal pure returns (uint72) {\n require(value <= type(uint72).max, \"SafeCast: value doesn't fit in 72 bits\");\n return uint72(value);\n }\n\n /**\n * @dev Returns the downcasted uint64 from uint256, reverting on\n * overflow (when the input is greater than largest uint64).\n *\n * Counterpart to Solidity's `uint64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n *\n * _Available since v2.5._\n */\n function toUint64(uint256 value) internal pure returns (uint64) {\n require(value <= type(uint64).max, \"SafeCast: value doesn't fit in 64 bits\");\n return uint64(value);\n }\n\n /**\n * @dev Returns the downcasted uint56 from uint256, reverting on\n * overflow (when the input is greater than largest uint56).\n *\n * Counterpart to Solidity's `uint56` operator.\n *\n * Requirements:\n *\n * - input must fit into 56 bits\n *\n * _Available since v4.7._\n */\n function toUint56(uint256 value) internal pure returns (uint56) {\n require(value <= type(uint56).max, \"SafeCast: value doesn't fit in 56 bits\");\n return uint56(value);\n }\n\n /**\n * @dev Returns the downcasted uint48 from uint256, reverting on\n * overflow (when the input is greater than largest uint48).\n *\n * Counterpart to Solidity's `uint48` operator.\n *\n * Requirements:\n *\n * - input must fit into 48 bits\n *\n * _Available since v4.7._\n */\n function toUint48(uint256 value) internal pure returns (uint48) {\n require(value <= type(uint48).max, \"SafeCast: value doesn't fit in 48 bits\");\n return uint48(value);\n }\n\n /**\n * @dev Returns the downcasted uint40 from uint256, reverting on\n * overflow (when the input is greater than largest uint40).\n *\n * Counterpart to Solidity's `uint40` operator.\n *\n * Requirements:\n *\n * - input must fit into 40 bits\n *\n * _Available since v4.7._\n */\n function toUint40(uint256 value) internal pure returns (uint40) {\n require(value <= type(uint40).max, \"SafeCast: value doesn't fit in 40 bits\");\n return uint40(value);\n }\n\n /**\n * @dev Returns the downcasted uint32 from uint256, reverting on\n * overflow (when the input is greater than largest uint32).\n *\n * Counterpart to Solidity's `uint32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n *\n * _Available since v2.5._\n */\n function toUint32(uint256 value) internal pure returns (uint32) {\n require(value <= type(uint32).max, \"SafeCast: value doesn't fit in 32 bits\");\n return uint32(value);\n }\n\n /**\n * @dev Returns the downcasted uint24 from uint256, reverting on\n * overflow (when the input is greater than largest uint24).\n *\n * Counterpart to Solidity's `uint24` operator.\n *\n * Requirements:\n *\n * - input must fit into 24 bits\n *\n * _Available since v4.7._\n */\n function toUint24(uint256 value) internal pure returns (uint24) {\n require(value <= type(uint24).max, \"SafeCast: value doesn't fit in 24 bits\");\n return uint24(value);\n }\n\n /**\n * @dev Returns the downcasted uint16 from uint256, reverting on\n * overflow (when the input is greater than largest uint16).\n *\n * Counterpart to Solidity's `uint16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n *\n * _Available since v2.5._\n */\n function toUint16(uint256 value) internal pure returns (uint16) {\n require(value <= type(uint16).max, \"SafeCast: value doesn't fit in 16 bits\");\n return uint16(value);\n }\n\n /**\n * @dev Returns the downcasted uint8 from uint256, reverting on\n * overflow (when the input is greater than largest uint8).\n *\n * Counterpart to Solidity's `uint8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits\n *\n * _Available since v2.5._\n */\n function toUint8(uint256 value) internal pure returns (uint8) {\n require(value <= type(uint8).max, \"SafeCast: value doesn't fit in 8 bits\");\n return uint8(value);\n }\n\n /**\n * @dev Converts a signed int256 into an unsigned uint256.\n *\n * Requirements:\n *\n * - input must be greater than or equal to 0.\n *\n * _Available since v3.0._\n */\n function toUint256(int256 value) internal pure returns (uint256) {\n require(value >= 0, \"SafeCast: value must be positive\");\n return uint256(value);\n }\n\n /**\n * @dev Returns the downcasted int248 from int256, reverting on\n * overflow (when the input is less than smallest int248 or\n * greater than largest int248).\n *\n * Counterpart to Solidity's `int248` operator.\n *\n * Requirements:\n *\n * - input must fit into 248 bits\n *\n * _Available since v4.7._\n */\n function toInt248(int256 value) internal pure returns (int248 downcasted) {\n downcasted = int248(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 248 bits\");\n }\n\n /**\n * @dev Returns the downcasted int240 from int256, reverting on\n * overflow (when the input is less than smallest int240 or\n * greater than largest int240).\n *\n * Counterpart to Solidity's `int240` operator.\n *\n * Requirements:\n *\n * - input must fit into 240 bits\n *\n * _Available since v4.7._\n */\n function toInt240(int256 value) internal pure returns (int240 downcasted) {\n downcasted = int240(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 240 bits\");\n }\n\n /**\n * @dev Returns the downcasted int232 from int256, reverting on\n * overflow (when the input is less than smallest int232 or\n * greater than largest int232).\n *\n * Counterpart to Solidity's `int232` operator.\n *\n * Requirements:\n *\n * - input must fit into 232 bits\n *\n * _Available since v4.7._\n */\n function toInt232(int256 value) internal pure returns (int232 downcasted) {\n downcasted = int232(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 232 bits\");\n }\n\n /**\n * @dev Returns the downcasted int224 from int256, reverting on\n * overflow (when the input is less than smallest int224 or\n * greater than largest int224).\n *\n * Counterpart to Solidity's `int224` operator.\n *\n * Requirements:\n *\n * - input must fit into 224 bits\n *\n * _Available since v4.7._\n */\n function toInt224(int256 value) internal pure returns (int224 downcasted) {\n downcasted = int224(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 224 bits\");\n }\n\n /**\n * @dev Returns the downcasted int216 from int256, reverting on\n * overflow (when the input is less than smallest int216 or\n * greater than largest int216).\n *\n * Counterpart to Solidity's `int216` operator.\n *\n * Requirements:\n *\n * - input must fit into 216 bits\n *\n * _Available since v4.7._\n */\n function toInt216(int256 value) internal pure returns (int216 downcasted) {\n downcasted = int216(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 216 bits\");\n }\n\n /**\n * @dev Returns the downcasted int208 from int256, reverting on\n * overflow (when the input is less than smallest int208 or\n * greater than largest int208).\n *\n * Counterpart to Solidity's `int208` operator.\n *\n * Requirements:\n *\n * - input must fit into 208 bits\n *\n * _Available since v4.7._\n */\n function toInt208(int256 value) internal pure returns (int208 downcasted) {\n downcasted = int208(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 208 bits\");\n }\n\n /**\n * @dev Returns the downcasted int200 from int256, reverting on\n * overflow (when the input is less than smallest int200 or\n * greater than largest int200).\n *\n * Counterpart to Solidity's `int200` operator.\n *\n * Requirements:\n *\n * - input must fit into 200 bits\n *\n * _Available since v4.7._\n */\n function toInt200(int256 value) internal pure returns (int200 downcasted) {\n downcasted = int200(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 200 bits\");\n }\n\n /**\n * @dev Returns the downcasted int192 from int256, reverting on\n * overflow (when the input is less than smallest int192 or\n * greater than largest int192).\n *\n * Counterpart to Solidity's `int192` operator.\n *\n * Requirements:\n *\n * - input must fit into 192 bits\n *\n * _Available since v4.7._\n */\n function toInt192(int256 value) internal pure returns (int192 downcasted) {\n downcasted = int192(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 192 bits\");\n }\n\n /**\n * @dev Returns the downcasted int184 from int256, reverting on\n * overflow (when the input is less than smallest int184 or\n * greater than largest int184).\n *\n * Counterpart to Solidity's `int184` operator.\n *\n * Requirements:\n *\n * - input must fit into 184 bits\n *\n * _Available since v4.7._\n */\n function toInt184(int256 value) internal pure returns (int184 downcasted) {\n downcasted = int184(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 184 bits\");\n }\n\n /**\n * @dev Returns the downcasted int176 from int256, reverting on\n * overflow (when the input is less than smallest int176 or\n * greater than largest int176).\n *\n * Counterpart to Solidity's `int176` operator.\n *\n * Requirements:\n *\n * - input must fit into 176 bits\n *\n * _Available since v4.7._\n */\n function toInt176(int256 value) internal pure returns (int176 downcasted) {\n downcasted = int176(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 176 bits\");\n }\n\n /**\n * @dev Returns the downcasted int168 from int256, reverting on\n * overflow (when the input is less than smallest int168 or\n * greater than largest int168).\n *\n * Counterpart to Solidity's `int168` operator.\n *\n * Requirements:\n *\n * - input must fit into 168 bits\n *\n * _Available since v4.7._\n */\n function toInt168(int256 value) internal pure returns (int168 downcasted) {\n downcasted = int168(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 168 bits\");\n }\n\n /**\n * @dev Returns the downcasted int160 from int256, reverting on\n * overflow (when the input is less than smallest int160 or\n * greater than largest int160).\n *\n * Counterpart to Solidity's `int160` operator.\n *\n * Requirements:\n *\n * - input must fit into 160 bits\n *\n * _Available since v4.7._\n */\n function toInt160(int256 value) internal pure returns (int160 downcasted) {\n downcasted = int160(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 160 bits\");\n }\n\n /**\n * @dev Returns the downcasted int152 from int256, reverting on\n * overflow (when the input is less than smallest int152 or\n * greater than largest int152).\n *\n * Counterpart to Solidity's `int152` operator.\n *\n * Requirements:\n *\n * - input must fit into 152 bits\n *\n * _Available since v4.7._\n */\n function toInt152(int256 value) internal pure returns (int152 downcasted) {\n downcasted = int152(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 152 bits\");\n }\n\n /**\n * @dev Returns the downcasted int144 from int256, reverting on\n * overflow (when the input is less than smallest int144 or\n * greater than largest int144).\n *\n * Counterpart to Solidity's `int144` operator.\n *\n * Requirements:\n *\n * - input must fit into 144 bits\n *\n * _Available since v4.7._\n */\n function toInt144(int256 value) internal pure returns (int144 downcasted) {\n downcasted = int144(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 144 bits\");\n }\n\n /**\n * @dev Returns the downcasted int136 from int256, reverting on\n * overflow (when the input is less than smallest int136 or\n * greater than largest int136).\n *\n * Counterpart to Solidity's `int136` operator.\n *\n * Requirements:\n *\n * - input must fit into 136 bits\n *\n * _Available since v4.7._\n */\n function toInt136(int256 value) internal pure returns (int136 downcasted) {\n downcasted = int136(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 136 bits\");\n }\n\n /**\n * @dev Returns the downcasted int128 from int256, reverting on\n * overflow (when the input is less than smallest int128 or\n * greater than largest int128).\n *\n * Counterpart to Solidity's `int128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n *\n * _Available since v3.1._\n */\n function toInt128(int256 value) internal pure returns (int128 downcasted) {\n downcasted = int128(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 128 bits\");\n }\n\n /**\n * @dev Returns the downcasted int120 from int256, reverting on\n * overflow (when the input is less than smallest int120 or\n * greater than largest int120).\n *\n * Counterpart to Solidity's `int120` operator.\n *\n * Requirements:\n *\n * - input must fit into 120 bits\n *\n * _Available since v4.7._\n */\n function toInt120(int256 value) internal pure returns (int120 downcasted) {\n downcasted = int120(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 120 bits\");\n }\n\n /**\n * @dev Returns the downcasted int112 from int256, reverting on\n * overflow (when the input is less than smallest int112 or\n * greater than largest int112).\n *\n * Counterpart to Solidity's `int112` operator.\n *\n * Requirements:\n *\n * - input must fit into 112 bits\n *\n * _Available since v4.7._\n */\n function toInt112(int256 value) internal pure returns (int112 downcasted) {\n downcasted = int112(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 112 bits\");\n }\n\n /**\n * @dev Returns the downcasted int104 from int256, reverting on\n * overflow (when the input is less than smallest int104 or\n * greater than largest int104).\n *\n * Counterpart to Solidity's `int104` operator.\n *\n * Requirements:\n *\n * - input must fit into 104 bits\n *\n * _Available since v4.7._\n */\n function toInt104(int256 value) internal pure returns (int104 downcasted) {\n downcasted = int104(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 104 bits\");\n }\n\n /**\n * @dev Returns the downcasted int96 from int256, reverting on\n * overflow (when the input is less than smallest int96 or\n * greater than largest int96).\n *\n * Counterpart to Solidity's `int96` operator.\n *\n * Requirements:\n *\n * - input must fit into 96 bits\n *\n * _Available since v4.7._\n */\n function toInt96(int256 value) internal pure returns (int96 downcasted) {\n downcasted = int96(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 96 bits\");\n }\n\n /**\n * @dev Returns the downcasted int88 from int256, reverting on\n * overflow (when the input is less than smallest int88 or\n * greater than largest int88).\n *\n * Counterpart to Solidity's `int88` operator.\n *\n * Requirements:\n *\n * - input must fit into 88 bits\n *\n * _Available since v4.7._\n */\n function toInt88(int256 value) internal pure returns (int88 downcasted) {\n downcasted = int88(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 88 bits\");\n }\n\n /**\n * @dev Returns the downcasted int80 from int256, reverting on\n * overflow (when the input is less than smallest int80 or\n * greater than largest int80).\n *\n * Counterpart to Solidity's `int80` operator.\n *\n * Requirements:\n *\n * - input must fit into 80 bits\n *\n * _Available since v4.7._\n */\n function toInt80(int256 value) internal pure returns (int80 downcasted) {\n downcasted = int80(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 80 bits\");\n }\n\n /**\n * @dev Returns the downcasted int72 from int256, reverting on\n * overflow (when the input is less than smallest int72 or\n * greater than largest int72).\n *\n * Counterpart to Solidity's `int72` operator.\n *\n * Requirements:\n *\n * - input must fit into 72 bits\n *\n * _Available since v4.7._\n */\n function toInt72(int256 value) internal pure returns (int72 downcasted) {\n downcasted = int72(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 72 bits\");\n }\n\n /**\n * @dev Returns the downcasted int64 from int256, reverting on\n * overflow (when the input is less than smallest int64 or\n * greater than largest int64).\n *\n * Counterpart to Solidity's `int64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n *\n * _Available since v3.1._\n */\n function toInt64(int256 value) internal pure returns (int64 downcasted) {\n downcasted = int64(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 64 bits\");\n }\n\n /**\n * @dev Returns the downcasted int56 from int256, reverting on\n * overflow (when the input is less than smallest int56 or\n * greater than largest int56).\n *\n * Counterpart to Solidity's `int56` operator.\n *\n * Requirements:\n *\n * - input must fit into 56 bits\n *\n * _Available since v4.7._\n */\n function toInt56(int256 value) internal pure returns (int56 downcasted) {\n downcasted = int56(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 56 bits\");\n }\n\n /**\n * @dev Returns the downcasted int48 from int256, reverting on\n * overflow (when the input is less than smallest int48 or\n * greater than largest int48).\n *\n * Counterpart to Solidity's `int48` operator.\n *\n * Requirements:\n *\n * - input must fit into 48 bits\n *\n * _Available since v4.7._\n */\n function toInt48(int256 value) internal pure returns (int48 downcasted) {\n downcasted = int48(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 48 bits\");\n }\n\n /**\n * @dev Returns the downcasted int40 from int256, reverting on\n * overflow (when the input is less than smallest int40 or\n * greater than largest int40).\n *\n * Counterpart to Solidity's `int40` operator.\n *\n * Requirements:\n *\n * - input must fit into 40 bits\n *\n * _Available since v4.7._\n */\n function toInt40(int256 value) internal pure returns (int40 downcasted) {\n downcasted = int40(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 40 bits\");\n }\n\n /**\n * @dev Returns the downcasted int32 from int256, reverting on\n * overflow (when the input is less than smallest int32 or\n * greater than largest int32).\n *\n * Counterpart to Solidity's `int32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n *\n * _Available since v3.1._\n */\n function toInt32(int256 value) internal pure returns (int32 downcasted) {\n downcasted = int32(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 32 bits\");\n }\n\n /**\n * @dev Returns the downcasted int24 from int256, reverting on\n * overflow (when the input is less than smallest int24 or\n * greater than largest int24).\n *\n * Counterpart to Solidity's `int24` operator.\n *\n * Requirements:\n *\n * - input must fit into 24 bits\n *\n * _Available since v4.7._\n */\n function toInt24(int256 value) internal pure returns (int24 downcasted) {\n downcasted = int24(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 24 bits\");\n }\n\n /**\n * @dev Returns the downcasted int16 from int256, reverting on\n * overflow (when the input is less than smallest int16 or\n * greater than largest int16).\n *\n * Counterpart to Solidity's `int16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n *\n * _Available since v3.1._\n */\n function toInt16(int256 value) internal pure returns (int16 downcasted) {\n downcasted = int16(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 16 bits\");\n }\n\n /**\n * @dev Returns the downcasted int8 from int256, reverting on\n * overflow (when the input is less than smallest int8 or\n * greater than largest int8).\n *\n * Counterpart to Solidity's `int8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits\n *\n * _Available since v3.1._\n */\n function toInt8(int256 value) internal pure returns (int8 downcasted) {\n downcasted = int8(value);\n require(downcasted == value, \"SafeCast: value doesn't fit in 8 bits\");\n }\n\n /**\n * @dev Converts an unsigned uint256 into a signed int256.\n *\n * Requirements:\n *\n * - input must be less than or equal to maxInt256.\n *\n * _Available since v3.0._\n */\n function toInt256(uint256 value) internal pure returns (int256) {\n // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n require(value <= uint256(type(int256).max), \"SafeCast: value doesn't fit in an int256\");\n return int256(value);\n }\n}\n","keccak256":"0x52a8cfb0f5239d11b457dcdd1b326992ef672714ca8da71a157255bddd13f3ad","license":"MIT"}},"version":1}