{"matchId":"43966017","creationMatch":null,"runtimeMatch":"match","verifiedAt":"2026-08-20T14:20:22Z","creationBytecode":{"onchainBytecode":null,"recompiledBytecode":"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","sourceMap":"2209:6306:10:-:0;;;;;;;;;;;;;-1:-1:-1;;2209:6306:10;;;;-1:-1:-1;;;;;2209:6306:10;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2209:6306:10;;;;;;2736:32;;2209:6306;;;;;;;;2736:32;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c634300081c000a","offset":7851}},"transformations":null,"transformationValues":null},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"2209:6306:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7386:9;2209:6306;;;;;;;;;;;7386:35;2209:6306;;7476:38;;;;:::i;:::-;7528:17;;7524:110;;2209:6306;;;;;7652:15;2209:6306;;;;;;;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;7386:9;2209:6306;;;;;;;;;;;7807:34;;;:::i;:::-;2209:6306;;;;;;;;;;;;;;;;;;;7859:34;2209:6306;;;;;;;;7958:24;;2209:6306;:::i;:::-;;7958:24;;;;;;:::i;:::-;7924:67;;;;;;2209:6306;;;;;7924:67;;;;;2209:6306;7924:67;;;2209:6306;7924:67;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;8010:38;;;2209:6306;8010:38;;2209:6306;;8010:38;2209:6306;8010:38;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;;;;;;;;;8122:79;2209:6306;8139:10;8122:79;;2209:6306;;;;;;;;;8010:38;;;2209:6306;8010:38;;2209:6306;8010:38;;;;;;2209:6306;8010:38;;;:::i;:::-;;;2209:6306;;;;;8010:38;;;2209:6306;-1:-1:-1;2209:6306:10;;8010:38;;;-1:-1:-1;8010:38:10;;;2209:6306;;;;;;;;;7924:67;;;;;:::i;:::-;2209:6306;;7924:67;;;;2209:6306;;;;7924:67;2209:6306;;;;;;;;;7924:67;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;7524:110;2209:6306;;;;;;;;;7620:13;;2209:6306;;7601:10;;7620:13;:::i;:::-;7524:110;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2607:52;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3076:13;;2209:6306;;;;;;3071:314;3108:3;3091:15;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3169:35;3177:4;;3169:35;;;;:::i;:::-;3222:8;;3218:157;;3108:3;2209:6306;;3076:13;;3218:157;3250:111;;;2209:6306;3250:111;;3091:15;;2209:6306;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;4959:48;2209:6306;4959:48;;2209:6306;4959:48;;2209:6306;4959:48;;2209:6306;;4975:14;2209:6306;4975:14;2209:6306;4975:14;2209:6306;4959:48;;;;;;;;;;;2209:6306;;;;;;;;5040:39;;5068:10;2209:6306;5040:39;;2209:6306;;5040:39;2209:6306;5040:39;;;;;;;;;;;;;2209:6306;;;;;5106:53;2209:6306;;;;5106:9;2209:6306;;;;;;;;;;;;;;;;;;;5106:53;2209:6306;;;;;5174:57;2209:6306;5068:10;5174:57;;2209:6306;;;;;;;;;5040:39;;;;2209:6306;5040:39;2209:6306;5040:39;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;4959:48;;;;2209:6306;4959:48;2209:6306;4959:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;3989:48;2209:6306;3989:48;;2209:6306;3989:48;;2209:6306;3989:48;;2209:6306;;4005:14;2209:6306;4005:14;2209:6306;4005:14;2209:6306;3989:48;;;;;;;;;;;2209:6306;;;;;4075:34;;;:::i;:::-;2209:6306;;;4127:39;;4155:10;2209:6306;4127:39;;2209:6306;;4127:39;2209:6306;4127:39;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;4247:72;2209:6306;4155:10;4247:72;;2209:6306;;;;;;;;;4127:39;;;;2209:6306;4127:39;2209:6306;4127:39;;;;;;;:::i;:::-;;;;;2209:6306;;;;;;;;;3989:48;;;;2209:6306;3989:48;2209:6306;3989:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5957:9;2209:6306;;;;;;;;;;;5957:35;2209:6306;;6047:38;;;;:::i;:::-;6099:17;;6095:143;;2209:6306;;;;;6255:15;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;6255:15;2209:6306;;;;;;;;;;;;;;;;;;;6426:54;;;:::i;:::-;2209:6306;;;;6498:17;2209:6306;;;;;;;;;;;;;;;;;;;;;;8451:54;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8451:54;;;;;;:::i;:::-;2209:6306;8441:65;;2209:6306;;;;;;;;;;;;;;;;;;;6660:34;2209:6306;;;;;;6771:34;;2209:6306;:::i;:::-;;6771:34;;;;;;:::i;:::-;6725:89;;;;;2209:6306;;6725:89;2209:6306;;;6725:89;;;;;2209:6306;6725:89;;;2209:6306;6725:89;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;6866:32;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6866:32;;;6771:34;6866:32;;:::i;:::-;6824:83;;;;;2209:6306;;6824:83;2209:6306;;6824:83;;;;;2209:6306;6824:83;;2209:6306;6824:83;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;6926:38;;;2209:6306;6926:38;;2209:6306;;6926:38;2209:6306;6926:38;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;7062:10;2209:6306;;;;;;;;;;;;;;;;;;;;;7038:136;;2209:6306;;7038:136;2209:6306;;;;;;;;;6926:38;;;2209:6306;6926:38;;2209:6306;6926:38;;;;;;2209:6306;6926:38;;;:::i;:::-;;;2209:6306;;;;;6926:38;;;;;;-1:-1:-1;6926:38:10;;;2209:6306;;;;;;;;;6824:83;;;;;:::i;:::-;2209:6306;;6824:83;;;;6725:89;;;;;;2209:6306;6725:89;;:::i;:::-;2209:6306;6725:89;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6095:143;2209:6306;;;;;;;;;6213:13;;2209:6306;;6194:10;;6213:13;:::i;:::-;6095:143;;;2209:6306;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;3541:48;2209:6306;3541:48;;2209:6306;3541:48;;2209:6306;3541:48;;2209:6306;;3557:14;2209:6306;3557:14;2209:6306;3557:14;2209:6306;3541:48;;;;;;;2209:6306;3541:48;;;2209:6306;;;;;;;;3622:39;;3650:10;2209:6306;3622:39;;2209:6306;;3622:39;2209:6306;3622:39;;;;;;;;;2209:6306;3622:39;;;2209:6306;;;;;3688:52;2209:6306;;;;;3688:15;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3688:52;2209:6306;;;;;;3650:10;3755:66;2209:6306;3650:10;3755:66;;2209:6306;;;;;;;;3622:39;;;;2209:6306;3622:39;2209:6306;3622:39;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;3541:48;;;;2209:6306;3541:48;2209:6306;3541:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;2290:39;2209:6306;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;5325:48;2209:6306;5325:48;;2209:6306;5325:48;;2209:6306;5325:48;;2209:6306;;5341:14;2209:6306;5341:14;2209:6306;5341:14;2209:6306;5325:48;;;;;;;2209:6306;5325:48;;;2209:6306;;;;;;;;5406:39;;5434:10;2209:6306;5406:39;;2209:6306;;5406:39;2209:6306;5406:39;;;;;;;;;2209:6306;5406:39;;;2209:6306;;;;;134:4:6;5480:17:10;;134:4:6;;2209:6306:10;;;5526:9;2209:6306;;;;;134:4:6;;;;;;;;;;;;;;2209:6306:10;;;;;5578:41;2209:6306;5434:10;5578:41;;2209:6306;134:4:6;;2209:6306:10;134:4:6;2209:6306:10;;134:4:6;5406:39:10;;;;2209:6306;5406:39;2209:6306;5406:39;;;;;;;:::i;:::-;;;;5325:48;;;;2209:6306;5325:48;2209:6306;5325:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;2520:81;2209:6306;;;;;;2520:81;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;4522:48;2209:6306;4522:48;;2209:6306;4522:48;;2209:6306;4522:48;;2209:6306;;4538:14;2209:6306;4538:14;2209:6306;4538:14;2209:6306;4522:48;;;;;;;2209:6306;4522:48;;;2209:6306;;;;;;;;4603:39;;4631:10;2209:6306;4603:39;;2209:6306;;4603:39;2209:6306;4603:39;;;;;;;;;2209:6306;4603:39;;;2209:6306;;;;;4669:83;2209:6306;;;;4669:17;2209:6306;;;;;4694:34;;;:::i;:::-;2209:6306;;;;;;;;;;;;;;;;;;;;;4669:83;2209:6306;;;;;;;;;;;;:::i;:::-;;;;;4767:84;2209:6306;4631:10;4767:84;;2209:6306;4603:39;;;;2209:6306;4603:39;2209:6306;4603:39;;;;;;;:::i;:::-;;;;4522:48;;;;2209:6306;4522:48;2209:6306;4522:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;2209:6306:10;;;;:::o;:::-;;;:::o;8318:195::-;2209:6306;;;8451:54;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8451:54;;;;;;:::i;:::-;2209:6306;8441:65;;8318:195;:::o;395:128:8:-;2209:6306:10;;;;;;;;;;;;;;;;;;;;;;134:4:6;2209:6306:10;;395:128:8;:::o;2209:6306:10:-;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;652:451:9;;761:17;;:21;2209:6306:10;;781:1:9;2209:6306:10;;;;;;;;867:54:9;;;;;;;;;2209:6306:10;867:54:9;;;2209:6306:10;;;;;;;;;;;867:54:9;;;;;;:::i;:::-;856:66;;;;;;:::i;:::-;2209:6306:10;;;;;;1000:22:9;;;:56;;;;;652:451;2209:6306:10;;;;;652:451:9:o;2209:6306:10:-;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10;1000:56:9;1026:30;;;867:54;1026:30;;;;;;;;:::i;:::-;1000:56;;;;2209:6306:10;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10;;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c634300081c000a","offset":7685}},"immutableReferences":{"1566":[{"start":1743,"length":32},{"start":2361,"length":32},{"start":4396,"length":32},{"start":4884,"length":32},{"start":5094,"length":32},{"start":5930,"length":32}]},"transformations":[{"id":"1566","type":"replace","offset":1743,"reason":"immutable"},{"id":"1566","type":"replace","offset":2361,"reason":"immutable"},{"id":"1566","type":"replace","offset":4396,"reason":"immutable"},{"id":"1566","type":"replace","offset":4884,"reason":"immutable"},{"id":"1566","type":"replace","offset":5094,"reason":"immutable"},{"id":"1566","type":"replace","offset":5930,"reason":"immutable"}],"transformationValues":{"immutables":{"1566":"0x0000000000000000000000004501125508079a99ebbebce205dec9593c2b5857"}}},"deployment":{"transactionHash":null,"blockNumber":null,"transactionIndex":null,"deployer":null},"sources":{"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\ntype Id is bytes32;\n\nstruct MarketParams {\n    address loanToken;\n    address collateralToken;\n    address oracle;\n    address irm;\n    uint256 lltv;\n}\n\n/// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest\n/// accrual.\nstruct Position {\n    uint256 supplyShares;\n    uint128 borrowShares;\n    uint128 collateral;\n}\n\n/// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n/// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n/// @dev Warning: `totalSupplyShares` does not contain the additional shares accrued by `feeRecipient` since the last\n/// interest accrual.\nstruct Market {\n    uint128 totalSupplyAssets;\n    uint128 totalSupplyShares;\n    uint128 totalBorrowAssets;\n    uint128 totalBorrowShares;\n    uint128 lastUpdate;\n    uint128 fee;\n}\n\nstruct Authorization {\n    address authorizer;\n    address authorized;\n    bool isAuthorized;\n    uint256 nonce;\n    uint256 deadline;\n}\n\nstruct Signature {\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n}\n\n/// @dev This interface is used for factorizing IMorphoStaticTyping and IMorpho.\n/// @dev Consider using the IMorpho interface instead of this one.\ninterface IMorphoBase {\n    /// @notice The EIP-712 domain separator.\n    /// @dev Warning: Every EIP-712 signed message based on this domain separator can be reused on chains sharing the\n    /// same chain id and on forks because the domain separator would be the same.\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n    /// @notice The owner of the contract.\n    /// @dev It has the power to change the owner.\n    /// @dev It has the power to set fees on markets and set the fee recipient.\n    /// @dev It has the power to enable but not disable IRMs and LLTVs.\n    function owner() external view returns (address);\n\n    /// @notice The fee recipient of all markets.\n    /// @dev The recipient receives the fees of a given market through a supply position on that market.\n    function feeRecipient() external view returns (address);\n\n    /// @notice Whether the `irm` is enabled.\n    function isIrmEnabled(address irm) external view returns (bool);\n\n    /// @notice Whether the `lltv` is enabled.\n    function isLltvEnabled(uint256 lltv) external view returns (bool);\n\n    /// @notice Whether `authorized` is authorized to modify `authorizer`'s position on all markets.\n    /// @dev Anyone is authorized to modify their own positions, regardless of this variable.\n    function isAuthorized(address authorizer, address authorized) external view returns (bool);\n\n    /// @notice The `authorizer`'s current nonce. Used to prevent replay attacks with EIP-712 signatures.\n    function nonce(address authorizer) external view returns (uint256);\n\n    /// @notice Sets `newOwner` as `owner` of the contract.\n    /// @dev Warning: No two-step transfer ownership.\n    /// @dev Warning: The owner can be set to the zero address.\n    function setOwner(address newOwner) external;\n\n    /// @notice Enables `irm` as a possible IRM for market creation.\n    /// @dev Warning: It is not possible to disable an IRM.\n    function enableIrm(address irm) external;\n\n    /// @notice Enables `lltv` as a possible LLTV for market creation.\n    /// @dev Warning: It is not possible to disable a LLTV.\n    function enableLltv(uint256 lltv) external;\n\n    /// @notice Sets the `newFee` for the given market `marketParams`.\n    /// @param newFee The new fee, scaled by WAD.\n    /// @dev Warning: The recipient can be the zero address.\n    function setFee(MarketParams memory marketParams, uint256 newFee) external;\n\n    /// @notice Sets `newFeeRecipient` as `feeRecipient` of the fee.\n    /// @dev Warning: If the fee recipient is set to the zero address, fees will accrue there and will be lost.\n    /// @dev Modifying the fee recipient will allow the new recipient to claim any pending fees not yet accrued. To\n    /// ensure that the current recipient receives all due fees, accrue interest manually prior to making any changes.\n    function setFeeRecipient(address newFeeRecipient) external;\n\n    /// @notice Creates the market `marketParams`.\n    /// @dev Here is the list of assumptions on the market's dependencies (tokens, IRM and oracle) that guarantees\n    /// Morpho behaves as expected:\n    /// - The token should be ERC-20 compliant, except that it can omit return values on `transfer` and `transferFrom`.\n    /// - The token balance of Morpho should only decrease on `transfer` and `transferFrom`. In particular, tokens with\n    /// burn functions are not supported.\n    /// - The token should not re-enter Morpho on `transfer` nor `transferFrom`.\n    /// - The token balance of the sender (resp. receiver) should decrease (resp. increase) by exactly the given amount\n    /// on `transfer` and `transferFrom`. In particular, tokens with fees on transfer are not supported.\n    /// - The IRM should not re-enter Morpho.\n    /// - The oracle should return a price with the correct scaling.\n    /// - The oracle price should not be able to change instantly such that the new price is less than the old price\n    /// multiplied by LLTV*LIF. In particular, if the loan asset is a vault that can receive donations, the oracle\n    /// should not price its shares using the AUM.\n    /// @dev Here is a list of assumptions on the market's dependencies which, if broken, could break Morpho's liveness\n    /// properties (funds could get stuck):\n    /// - The token should not revert on `transfer` and `transferFrom` if balances and approvals are right.\n    /// - The amount of assets supplied and borrowed should not be too high (max ~1e32), otherwise the number of shares\n    /// might not fit within 128 bits.\n    /// - The IRM should not revert on `borrowRate`.\n    /// - The IRM should not return a very high borrow rate (otherwise the computation of `interest` in\n    /// `_accrueInterest` can overflow).\n    /// - The oracle should not revert `price`.\n    /// - The oracle should not return a very high price (otherwise the computation of `maxBorrow` in `_isHealthy` or of\n    /// `assetsRepaid` in `liquidate` can overflow).\n    /// @dev The borrow share price of a market with less than 1e4 assets borrowed can be decreased by manipulations, to\n    /// the point where `totalBorrowShares` is very large and borrowing overflows.\n    function createMarket(MarketParams memory marketParams) external;\n\n    /// @notice Supplies `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoSupply` function with the given `data`.\n    /// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the\n    /// caller is guaranteed to have `assets` tokens pulled from their balance, but the possibility to mint a specific\n    /// amount of shares is given for full compatibility and precision.\n    /// @dev Supplying a large amount can revert for overflow.\n    /// @dev Supplying an amount of shares may lead to supply more or fewer assets than expected due to slippage.\n    /// Consider using the `assets` parameter to avoid this.\n    /// @param marketParams The market to supply assets to.\n    /// @param assets The amount of assets to supply.\n    /// @param shares The amount of shares to mint.\n    /// @param onBehalf The address that will own the increased supply position.\n    /// @param data Arbitrary data to pass to the `onMorphoSupply` callback. Pass empty data if not needed.\n    /// @return assetsSupplied The amount of assets supplied.\n    /// @return sharesSupplied The amount of shares minted.\n    function supply(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        bytes memory data\n    ) external returns (uint256 assetsSupplied, uint256 sharesSupplied);\n\n    /// @notice Withdraws `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev Either `assets` or `shares` should be zero. To withdraw max, pass the `shares`'s balance of `onBehalf`.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Withdrawing an amount corresponding to more shares than supplied will revert for underflow.\n    /// @dev It is advised to use the `shares` input when withdrawing the full position to avoid reverts due to\n    /// conversion roundings between shares and assets.\n    /// @param marketParams The market to withdraw assets from.\n    /// @param assets The amount of assets to withdraw.\n    /// @param shares The amount of shares to burn.\n    /// @param onBehalf The address of the owner of the supply position.\n    /// @param receiver The address that will receive the withdrawn assets.\n    /// @return assetsWithdrawn The amount of assets withdrawn.\n    /// @return sharesWithdrawn The amount of shares burned.\n    function withdraw(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        address receiver\n    ) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn);\n\n    /// @notice Borrows `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the\n    /// caller is guaranteed to borrow `assets` of tokens, but the possibility to mint a specific amount of shares is\n    /// given for full compatibility and precision.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Borrowing a large amount can revert for overflow.\n    /// @dev Borrowing an amount of shares may lead to borrow fewer assets than expected due to slippage.\n    /// Consider using the `assets` parameter to avoid this.\n    /// @param marketParams The market to borrow assets from.\n    /// @param assets The amount of assets to borrow.\n    /// @param shares The amount of shares to mint.\n    /// @param onBehalf The address that will own the increased borrow position.\n    /// @param receiver The address that will receive the borrowed assets.\n    /// @return assetsBorrowed The amount of assets borrowed.\n    /// @return sharesBorrowed The amount of shares minted.\n    function borrow(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        address receiver\n    ) external returns (uint256 assetsBorrowed, uint256 sharesBorrowed);\n\n    /// @notice Repays `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoRepay` function with the given `data`.\n    /// @dev Either `assets` or `shares` should be zero. To repay max, pass the `shares`'s balance of `onBehalf`.\n    /// @dev Repaying an amount corresponding to more shares than borrowed will revert for underflow.\n    /// @dev It is advised to use the `shares` input when repaying the full position to avoid reverts due to conversion\n    /// roundings between shares and assets.\n    /// @dev An attacker can front-run a repay with a small repay making the transaction revert for underflow.\n    /// @param marketParams The market to repay assets to.\n    /// @param assets The amount of assets to repay.\n    /// @param shares The amount of shares to burn.\n    /// @param onBehalf The address of the owner of the debt position.\n    /// @param data Arbitrary data to pass to the `onMorphoRepay` callback. Pass empty data if not needed.\n    /// @return assetsRepaid The amount of assets repaid.\n    /// @return sharesRepaid The amount of shares burned.\n    function repay(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        bytes memory data\n    ) external returns (uint256 assetsRepaid, uint256 sharesRepaid);\n\n    /// @notice Supplies `assets` of collateral on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoSupplyCollateral` function with the given `data`.\n    /// @dev Interest are not accrued since it's not required and it saves gas.\n    /// @dev Supplying a large amount can revert for overflow.\n    /// @param marketParams The market to supply collateral to.\n    /// @param assets The amount of collateral to supply.\n    /// @param onBehalf The address that will own the increased collateral position.\n    /// @param data Arbitrary data to pass to the `onMorphoSupplyCollateral` callback. Pass empty data if not needed.\n    function supplyCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, bytes memory data)\n        external;\n\n    /// @notice Withdraws `assets` of collateral on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Withdrawing an amount corresponding to more collateral than supplied will revert for underflow.\n    /// @param marketParams The market to withdraw collateral from.\n    /// @param assets The amount of collateral to withdraw.\n    /// @param onBehalf The address of the owner of the collateral position.\n    /// @param receiver The address that will receive the collateral assets.\n    function withdrawCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, address receiver)\n        external;\n\n    /// @notice Liquidates the given `repaidShares` of debt asset or seize the given `seizedAssets` of collateral on the\n    /// given market `marketParams` of the given `borrower`'s position, optionally calling back the caller's\n    /// `onMorphoLiquidate` function with the given `data`.\n    /// @dev Either `seizedAssets` or `repaidShares` should be zero.\n    /// @dev Seizing more than the collateral balance will underflow and revert without any error message.\n    /// @dev Repaying more than the borrow balance will underflow and revert without any error message.\n    /// @dev An attacker can front-run a liquidation with a small repay making the transaction revert for underflow.\n    /// @param marketParams The market of the position.\n    /// @param borrower The owner of the position.\n    /// @param seizedAssets The amount of collateral to seize.\n    /// @param repaidShares The amount of shares to repay.\n    /// @param data Arbitrary data to pass to the `onMorphoLiquidate` callback. Pass empty data if not needed.\n    /// @return The amount of assets seized.\n    /// @return The amount of assets repaid.\n    function liquidate(\n        MarketParams memory marketParams,\n        address borrower,\n        uint256 seizedAssets,\n        uint256 repaidShares,\n        bytes memory data\n    ) external returns (uint256, uint256);\n\n    /// @notice Executes a flash loan.\n    /// @dev Flash loans have access to the whole balance of the contract (the liquidity and deposited collateral of all\n    /// markets combined, plus donations).\n    /// @dev Warning: Not ERC-3156 compliant but compatibility is easily reached:\n    /// - `flashFee` is zero.\n    /// - `maxFlashLoan` is the token's balance of this contract.\n    /// - The receiver of `assets` is the caller.\n    /// @param token The token to flash loan.\n    /// @param assets The amount of assets to flash loan.\n    /// @param data Arbitrary data to pass to the `onMorphoFlashLoan` callback.\n    function flashLoan(address token, uint256 assets, bytes calldata data) external;\n\n    /// @notice Sets the authorization for `authorized` to manage `msg.sender`'s positions.\n    /// @param authorized The authorized address.\n    /// @param newIsAuthorized The new authorization status.\n    function setAuthorization(address authorized, bool newIsAuthorized) external;\n\n    /// @notice Sets the authorization for `authorization.authorized` to manage `authorization.authorizer`'s positions.\n    /// @dev Warning: Reverts if the signature has already been submitted.\n    /// @dev The signature is malleable, but it has no impact on the security here.\n    /// @dev The nonce is passed as argument to be able to revert with a different error message.\n    /// @param authorization The `Authorization` struct.\n    /// @param signature The signature.\n    function setAuthorizationWithSig(Authorization calldata authorization, Signature calldata signature) external;\n\n    /// @notice Accrues interest for the given market `marketParams`.\n    function accrueInterest(MarketParams memory marketParams) external;\n\n    /// @notice Returns the data stored on the different `slots`.\n    function extSloads(bytes32[] memory slots) external view returns (bytes32[] memory);\n}\n\n/// @dev This interface is inherited by Morpho so that function signatures are checked by the compiler.\n/// @dev Consider using the IMorpho interface instead of this one.\ninterface IMorphoStaticTyping is IMorphoBase {\n    /// @notice The state of the position of `user` on the market corresponding to `id`.\n    /// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest\n    /// accrual.\n    function position(Id id, address user)\n        external\n        view\n        returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral);\n\n    /// @notice The state of the market corresponding to `id`.\n    /// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last interest\n    /// accrual.\n    function market(Id id)\n        external\n        view\n        returns (\n            uint128 totalSupplyAssets,\n            uint128 totalSupplyShares,\n            uint128 totalBorrowAssets,\n            uint128 totalBorrowShares,\n            uint128 lastUpdate,\n            uint128 fee\n        );\n\n    /// @notice The market params corresponding to `id`.\n    /// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer\n    /// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.\n    function idToMarketParams(Id id)\n        external\n        view\n        returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv);\n}\n\n/// @title IMorpho\n/// @author Morpho Labs\n/// @custom:contact security@morpho.org\n/// @dev Use this interface for Morpho to have access to all the functions with the appropriate function signatures.\ninterface IMorpho is IMorphoBase {\n    /// @notice The state of the position of `user` on the market corresponding to `id`.\n    /// @dev Warning: For `feeRecipient`, `p.supplyShares` does not contain the accrued shares since the last interest\n    /// accrual.\n    function position(Id id, address user) external view returns (Position memory p);\n\n    /// @notice The state of the market corresponding to `id`.\n    /// @dev Warning: `m.totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `m.totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `m.totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last\n    /// interest accrual.\n    function market(Id id) external view returns (Market memory m);\n\n    /// @notice The market params corresponding to `id`.\n    /// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer\n    /// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.\n    function idToMarketParams(Id id) external view returns (MarketParams memory);\n}\n"},"lib/vault-v2/src/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IERC20 {\n    function decimals() external view returns (uint8);\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function totalSupply() external view returns (uint256);\n    function balanceOf(address account) external view returns (uint256);\n    function transfer(address to, uint256 shares) external returns (bool success);\n    function transferFrom(address from, address to, uint256 shares) external returns (bool success);\n    function approve(address spender, uint256 shares) external returns (bool success);\n    function allowance(address owner, address spender) external view returns (uint256);\n}\n"},"lib/vault-v2/src/interfaces/IERC2612.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IERC2612 {\n    function permit(address owner, address spender, uint256 shares, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n        external;\n    function nonces(address owner) external view returns (uint256);\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"lib/vault-v2/src/interfaces/IERC4626.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\nimport {IERC20} from \"./IERC20.sol\";\n\ninterface IERC4626 is IERC20 {\n    function asset() external view returns (address);\n    function totalAssets() external view returns (uint256);\n    function convertToAssets(uint256 shares) external view returns (uint256 assets);\n    function convertToShares(uint256 assets) external view returns (uint256 shares);\n    function deposit(uint256 assets, address onBehalf) external returns (uint256 shares);\n    function mint(uint256 shares, address onBehalf) external returns (uint256 assets);\n    function withdraw(uint256 assets, address receiver, address onBehalf) external returns (uint256 shares);\n    function redeem(uint256 shares, address receiver, address onBehalf) external returns (uint256 assets);\n    function previewDeposit(uint256 assets) external view returns (uint256 shares);\n    function previewMint(uint256 shares) external view returns (uint256 assets);\n    function previewWithdraw(uint256 assets) external view returns (uint256 shares);\n    function previewRedeem(uint256 shares) external view returns (uint256 assets);\n    function maxDeposit(address onBehalf) external view returns (uint256 assets);\n    function maxMint(address onBehalf) external view returns (uint256 shares);\n    function maxWithdraw(address onBehalf) external view returns (uint256 assets);\n    function maxRedeem(address onBehalf) external view returns (uint256 shares);\n}\n"},"lib/vault-v2/src/interfaces/IVaultV2.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\nimport {IERC4626} from \"./IERC4626.sol\";\nimport {IERC2612} from \"./IERC2612.sol\";\n\nstruct Caps {\n    uint256 allocation;\n    uint128 absoluteCap;\n    uint128 relativeCap;\n}\n\ninterface IVaultV2 is IERC4626, IERC2612 {\n    // State variables\n    function virtualShares() external view returns (uint256);\n    function owner() external view returns (address);\n    function curator() external view returns (address);\n    function receiveSharesGate() external view returns (address);\n    function sendSharesGate() external view returns (address);\n    function receiveAssetsGate() external view returns (address);\n    function sendAssetsGate() external view returns (address);\n    function adapterRegistry() external view returns (address);\n    function isSentinel(address account) external view returns (bool);\n    function isAllocator(address account) external view returns (bool);\n    function firstTotalAssets() external view returns (uint256);\n    function _totalAssets() external view returns (uint128);\n    function lastUpdate() external view returns (uint64);\n    function maxRate() external view returns (uint64);\n    function adapters(uint256 index) external view returns (address);\n    function adaptersLength() external view returns (uint256);\n    function isAdapter(address account) external view returns (bool);\n    function allocation(bytes32 id) external view returns (uint256);\n    function absoluteCap(bytes32 id) external view returns (uint256);\n    function relativeCap(bytes32 id) external view returns (uint256);\n    function forceDeallocatePenalty(address adapter) external view returns (uint256);\n    function liquidityAdapter() external view returns (address);\n    function liquidityData() external view returns (bytes memory);\n    function timelock(bytes4 selector) external view returns (uint256);\n    function abdicated(bytes4 selector) external view returns (bool);\n    function executableAt(bytes memory data) external view returns (uint256);\n    function performanceFee() external view returns (uint96);\n    function performanceFeeRecipient() external view returns (address);\n    function managementFee() external view returns (uint96);\n    function managementFeeRecipient() external view returns (address);\n\n    // Gating\n    function canSendShares(address account) external view returns (bool);\n    function canReceiveShares(address account) external view returns (bool);\n    function canSendAssets(address account) external view returns (bool);\n    function canReceiveAssets(address account) external view returns (bool);\n\n    // Multicall\n    function multicall(bytes[] memory data) external;\n\n    // Owner functions\n    function setOwner(address newOwner) external;\n    function setCurator(address newCurator) external;\n    function setIsSentinel(address account, bool isSentinel) external;\n    function setName(string memory newName) external;\n    function setSymbol(string memory newSymbol) external;\n\n    // Timelocks for curator functions\n    function submit(bytes memory data) external;\n    function revoke(bytes memory data) external;\n\n    // Curator functions\n    function setIsAllocator(address account, bool newIsAllocator) external;\n    function setReceiveSharesGate(address newReceiveSharesGate) external;\n    function setSendSharesGate(address newSendSharesGate) external;\n    function setReceiveAssetsGate(address newReceiveAssetsGate) external;\n    function setSendAssetsGate(address newSendAssetsGate) external;\n    function setAdapterRegistry(address newAdapterRegistry) external;\n    function addAdapter(address account) external;\n    function removeAdapter(address account) external;\n    function increaseTimelock(bytes4 selector, uint256 newDuration) external;\n    function decreaseTimelock(bytes4 selector, uint256 newDuration) external;\n    function abdicate(bytes4 selector) external;\n    function setPerformanceFee(uint256 newPerformanceFee) external;\n    function setManagementFee(uint256 newManagementFee) external;\n    function setPerformanceFeeRecipient(address newPerformanceFeeRecipient) external;\n    function setManagementFeeRecipient(address newManagementFeeRecipient) external;\n    function increaseAbsoluteCap(bytes memory idData, uint256 newAbsoluteCap) external;\n    function decreaseAbsoluteCap(bytes memory idData, uint256 newAbsoluteCap) external;\n    function increaseRelativeCap(bytes memory idData, uint256 newRelativeCap) external;\n    function decreaseRelativeCap(bytes memory idData, uint256 newRelativeCap) external;\n    function setMaxRate(uint256 newMaxRate) external;\n    function setForceDeallocatePenalty(address adapter, uint256 newForceDeallocatePenalty) external;\n\n    // Allocator functions\n    function allocate(address adapter, bytes memory data, uint256 assets) external;\n    function deallocate(address adapter, bytes memory data, uint256 assets) external;\n    function setLiquidityAdapterAndData(address newLiquidityAdapter, bytes memory newLiquidityData) external;\n\n    // Exchange rate\n    function accrueInterest() external;\n    function accrueInterestView()\n        external\n        view\n        returns (uint256 newTotalAssets, uint256 performanceFeeShares, uint256 managementFeeShares);\n\n    // Force deallocate\n    function forceDeallocate(address adapter, bytes memory data, uint256 assets, address onBehalf)\n        external\n        returns (uint256 penaltyShares);\n}\n"},"lib/vault-v2/src/interfaces/IVaultV2Factory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IVaultV2Factory {\n    /* EVENTS */\n\n    event CreateVaultV2(address indexed owner, address indexed asset, bytes32 salt, address indexed newVaultV2);\n\n    /* FUNCTIONS */\n\n    function isVaultV2(address account) external view returns (bool);\n    function vaultV2(address owner, address asset, bytes32 salt) external view returns (address);\n    function createVaultV2(address owner, address asset, bytes32 salt) external returns (address newVaultV2);\n}\n"},"lib/vault-v2/src/libraries/ConstantsLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nuint256 constant WAD = 1e18;\nbytes32 constant DOMAIN_TYPEHASH = keccak256(\"EIP712Domain(uint256 chainId,address verifyingContract)\");\nbytes32 constant PERMIT_TYPEHASH =\n    keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\nuint256 constant MAX_MAX_RATE = 200e16 / uint256(365 days); // 200% APR\nuint256 constant MAX_PERFORMANCE_FEE = 0.5e18; // 50%\nuint256 constant MAX_MANAGEMENT_FEE = 0.05e18 / uint256(365 days); // 5%\nuint256 constant MAX_FORCE_DEALLOCATE_PENALTY = 0.02e18; // 2%\n"},"lib/vault-v2/src/libraries/ErrorsLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nlibrary ErrorsLib {\n    error Abdicated();\n    error AbsoluteCapExceeded();\n    error AbsoluteCapNotDecreasing();\n    error AbsoluteCapNotIncreasing();\n    error ApproveReturnedFalse();\n    error ApproveReverted();\n    error AutomaticallyTimelocked();\n    error CannotReceiveShares();\n    error CannotReceiveAssets();\n    error CannotSendShares();\n    error CannotSendAssets();\n    error CapExceeded();\n    error CastOverflow();\n    error DataAlreadyPending();\n    error DataNotTimelocked();\n    error FeeInvariantBroken();\n    error FeeTooHigh();\n    error InvalidSigner();\n    error MaxRateTooHigh();\n    error NoCode();\n    error NotAdapter();\n    error NotInAdapterRegistry();\n    error PenaltyTooHigh();\n    error PermitDeadlineExpired();\n    error RelativeCapAboveOne();\n    error RelativeCapExceeded();\n    error RelativeCapNotDecreasing();\n    error RelativeCapNotIncreasing();\n    error TimelockNotDecreasing();\n    error TimelockNotExpired();\n    error TimelockNotIncreasing();\n    error TransferFromReturnedFalse();\n    error TransferFromReverted();\n    error TransferReturnedFalse();\n    error TransferReverted();\n    error Unauthorized();\n    error ZeroAbsoluteCap();\n    error ZeroAddress();\n    error ZeroAllocation();\n}\n"},"lib/vault-v2/src/libraries/MathLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nimport {ErrorsLib} from \"./ErrorsLib.sol\";\n\nlibrary MathLib {\n    /// @dev Returns (x * y) / d rounded down.\n    function mulDivDown(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {\n        return (x * y) / d;\n    }\n\n    /// @dev Returns (x * y) / d rounded up.\n    function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {\n        return (x * y + (d - 1)) / d;\n    }\n\n    /// @dev Returns max(0, x - y).\n    function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {\n        assembly {\n            z := mul(gt(x, y), sub(x, y))\n        }\n    }\n\n    /// @dev Casts from uint256 to uint128, reverting if input number is too large.\n    function toUint128(uint256 x) internal pure returns (uint128) {\n        require(x <= type(uint128).max, ErrorsLib.CastOverflow());\n        // forge-lint: disable-next-item(unsafe-typecast) safe because x <= type(uint128).max.\n        return uint128(x);\n    }\n\n    /// @dev Casts from int256 to uint256, reverting if input number is negative.\n    function toUint256(int256 x) internal pure returns (uint256) {\n        require(x >= 0, ErrorsLib.CastOverflow());\n        // forge-lint: disable-next-item(unsafe-typecast) safe because x >= 0.\n        return uint256(x);\n    }\n\n    /// @dev Returns min(x, y).\n    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {\n        assembly {\n            z := xor(x, mul(xor(x, y), lt(y, x)))\n        }\n    }\n}\n"},"lib/vault-v2/src/libraries/SafeERC20Lib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nimport {IERC20} from \"../interfaces/IERC20.sol\";\nimport {ErrorsLib} from \"./ErrorsLib.sol\";\n\nlibrary SafeERC20Lib {\n    function safeTransfer(address token, address to, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.transfer, (to, value)));\n        require(success, ErrorsLib.TransferReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.TransferReturnedFalse());\n    }\n\n    function safeTransferFrom(address token, address from, address to, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.transferFrom, (from, to, value)));\n        require(success, ErrorsLib.TransferFromReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.TransferFromReturnedFalse());\n    }\n\n    function safeApprove(address token, address spender, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.approve, (spender, value)));\n        require(success, ErrorsLib.ApproveReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.ApproveReturnedFalse());\n    }\n}\n"},"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2026 Morpho Association\npragma solidity 0.8.28;\n\nimport {IVaultV2} from \"../../interfaces/IVaultV2.sol\";\nimport {IVaultV2Factory} from \"../../interfaces/IVaultV2Factory.sol\";\nimport {IBluePublicAllocator, VaultData} from \"./interfaces/IBluePublicAllocator.sol\";\nimport {MarketParams} from \"../../../lib/morpho-blue/src/interfaces/IMorpho.sol\";\nimport {WAD} from \"../../libraries/ConstantsLib.sol\";\nimport {MathLib} from \"../../libraries/MathLib.sol\";\nimport {SafeERC20Lib} from \"../../libraries/SafeERC20Lib.sol\";\n\n/// @dev To be usable, the BluePublicAllocator must be set as an allocator of the vault.\n/// @dev Meant to be used with VaultV2 vaults only.\n/// @dev Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system\n/// could break.\n/// @dev The vault's allocators can manage the public allocators' settings.\n/// @dev Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's\n/// asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which\n/// increases the rate like forceDeallocate penalties).\n/// @dev The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between\n/// signing and execution.\n/// @dev The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.\n/// @dev The public allocator's caps are not checked on allocations from the vault (either by allocators or through\n/// deposits).\n/// @dev The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but\n/// it requires capital).\n/// @dev reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an\n/// allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.\n/// @dev Reallocations (notably through this contract) can reduce the vault's \"direct\" liquidity by pulling assets from\n/// idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.\ncontract BluePublicAllocator is IBluePublicAllocator {\n    /* IMMUTABLES */\n\n    address public immutable vaultV2Factory;\n\n    /* STORAGE */\n\n    mapping(address vault => mapping(bytes32 id => uint256)) public absoluteCap;\n    mapping(address vault => mapping(bytes32 id => bool)) public canPullFromMarket;\n    mapping(address vault => mapping(address adapter => bool)) public isActiveAdapter;\n    mapping(address vault => VaultData) public vaultData;\n\n    /* CONSTRUCTOR */\n\n    constructor(address _vaultV2Factory) {\n        vaultV2Factory = _vaultV2Factory;\n    }\n\n    /* MULTICALL */\n\n    /// @dev Useful for EOAs to batch allocator calls.\n    /// @dev Does not return anything, because accounts who would use the return data would be contracts, which can do\n    /// the multicall themselves.\n    function multicall(bytes[] calldata data) external {\n        for (uint256 i = 0; i < data.length; i++) {\n            (bool success, bytes memory returnData) = address(this).delegatecall(data[i]);\n            if (!success) {\n                assembly (\"memory-safe\") {\n                    revert(add(32, returnData), mload(returnData))\n                }\n            }\n        }\n    }\n\n    /* AUTHORIZED FUNCTIONS */\n\n    function setIsActiveAdapter(address vault, address adapter, bool newIsActiveAdapter) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        isActiveAdapter[vault][adapter] = newIsActiveAdapter;\n        emit SetIsActiveAdapter(msg.sender, vault, adapter, newIsActiveAdapter);\n    }\n\n    function setAbsoluteCap(address vault, address adapter, MarketParams calldata marketParams, uint256 newAbsoluteCap)\n        external\n    {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        bytes32 id = vaultBlueId(adapter, marketParams);\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        absoluteCap[vault][id] = newAbsoluteCap;\n        emit SetAbsoluteCap(msg.sender, vault, adapter, marketParams, newAbsoluteCap);\n    }\n\n    function setCanPullFromMarket(\n        address vault,\n        address adapter,\n        MarketParams calldata marketParams,\n        bool newCanPullFromMarket\n    ) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        canPullFromMarket[vault][vaultBlueId(adapter, marketParams)] = newCanPullFromMarket;\n        emit SetCanPullFromMarket(msg.sender, vault, adapter, marketParams, newCanPullFromMarket);\n    }\n\n    function setCanPullFromIdle(address vault, bool newCanPullFromIdle) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        vaultData[vault].canPullFromIdle = newCanPullFromIdle;\n        emit SetCanPullFromIdle(msg.sender, vault, newCanPullFromIdle);\n    }\n\n    function setPenalty(address vault, uint64 newPenalty) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        require(newPenalty <= WAD, PenaltyTooHigh());\n        vaultData[vault].penalty = newPenalty;\n        emit SetPenalty(msg.sender, vault, newPenalty);\n    }\n\n    /* PUBLIC FUNCTION */\n\n    function reallocate(\n        address vault,\n        address deallocateAdapter,\n        MarketParams calldata deallocateMarketParams,\n        address allocateAdapter,\n        MarketParams calldata allocateMarketParams,\n        uint128 assets,\n        uint64 penalty\n    ) external {\n        require(vaultData[vault].penalty == penalty, IncorrectPenalty());\n        uint256 penaltyAssets = MathLib.mulDivUp(assets, penalty, WAD);\n        if (penaltyAssets > 0) {\n            SafeERC20Lib.safeTransferFrom(allocateMarketParams.loanToken, msg.sender, vault, penaltyAssets);\n        }\n        require(isActiveAdapter[vault][deallocateAdapter], InactiveAdapter());\n        require(isActiveAdapter[vault][allocateAdapter], InactiveAdapter());\n        bytes32 deallocateId = vaultBlueId(deallocateAdapter, deallocateMarketParams);\n        require(canPullFromMarket[vault][deallocateId], CannotPullFromMarket());\n        bytes32 allocateId = vaultBlueId(allocateAdapter, allocateMarketParams);\n        require(absoluteCap[vault][allocateId] > 0, ZeroAbsoluteCap());\n\n        IVaultV2(vault).deallocate(deallocateAdapter, abi.encode(deallocateMarketParams), assets);\n        IVaultV2(vault).allocate(allocateAdapter, abi.encode(allocateMarketParams), assets);\n\n        require(IVaultV2(vault).allocation(allocateId) <= absoluteCap[vault][allocateId], AbsoluteCapExceeded());\n\n        emit Reallocate(\n            msg.sender, vault, deallocateAdapter, deallocateId, allocateAdapter, allocateId, assets, penaltyAssets\n        );\n    }\n\n    function allocateFromIdle(\n        address vault,\n        address adapter,\n        MarketParams calldata marketParams,\n        uint128 assets,\n        uint64 penalty\n    ) external {\n        require(vaultData[vault].penalty == penalty, IncorrectPenalty());\n        uint256 penaltyAssets = MathLib.mulDivUp(assets, penalty, WAD);\n        if (penaltyAssets > 0) SafeERC20Lib.safeTransferFrom(marketParams.loanToken, msg.sender, vault, penaltyAssets);\n        require(isActiveAdapter[vault][adapter], InactiveAdapter());\n        require(vaultData[vault].canPullFromIdle, CannotPullFromIdle());\n        bytes32 allocateId = vaultBlueId(adapter, marketParams);\n        require(absoluteCap[vault][allocateId] > 0, ZeroAbsoluteCap());\n\n        IVaultV2(vault).allocate(adapter, abi.encode(marketParams), assets);\n\n        require(IVaultV2(vault).allocation(allocateId) <= absoluteCap[vault][allocateId], AbsoluteCapExceeded());\n\n        emit AllocateFromIdle(msg.sender, vault, adapter, allocateId, assets, penaltyAssets);\n    }\n\n    /// @dev Returns the market's per-market vault id, exactly as keyed by the MorphoMarketV1AdapterV2.\n    function vaultBlueId(address adapter, MarketParams calldata marketParams) internal pure returns (bytes32) {\n        return keccak256(abi.encode(\"this/marketParams\", adapter, marketParams));\n    }\n}\n"},"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2026 Morpho Association\npragma solidity >=0.8.0;\n\nimport {MarketParams} from \"../../../../lib/morpho-blue/src/interfaces/IMorpho.sol\";\n\nstruct VaultData {\n    bool canPullFromIdle;\n    uint64 penalty;\n}\n\n// forgefmt: disable-start\ninterface IBluePublicAllocator {\n\n    /* EVENTS */\n\n    event SetAbsoluteCap(address indexed sender, address indexed vault, address adapter, MarketParams marketParams, uint256 absoluteCap);\n    event SetCanPullFromMarket(address indexed sender, address indexed vault, address adapter, MarketParams marketParams, bool canPullFromMarket);\n    event SetCanPullFromIdle(address indexed sender, address indexed vault, bool canPullFromIdle);\n    event SetIsActiveAdapter(address indexed sender, address indexed vault, address indexed adapter, bool isActiveAdapter);\n    event SetPenalty(address indexed sender, address indexed vault, uint64 newPenalty);\n    event Reallocate(address sender, address indexed vault, address deallocateAdapter, bytes32 indexed deallocateId, address allocateAdapter, bytes32 indexed allocateId, uint128 assets, uint256 penaltyAssets);\n    event AllocateFromIdle(address indexed sender, address indexed vault, address adapter, bytes32 indexed allocateId, uint128 assets, uint256 penaltyAssets);\n\n    /* ERRORS */\n\n    error Unauthorized();\n    error AbsoluteCapExceeded();\n    error ZeroAbsoluteCap();\n    error CannotPullFromMarket();\n    error CannotPullFromIdle();\n    error InactiveAdapter();\n    error PenaltyTooHigh();\n    error IncorrectPenalty();\n    error NotVaultV2();\n\n    /* VIEW */\n\n    function vaultV2Factory() external view returns (address);\n    function absoluteCap(address vault, bytes32 id) external view returns (uint256);\n    function canPullFromMarket(address vault, bytes32 id) external view returns (bool);\n    function isActiveAdapter(address vault, address adapter) external view returns (bool);\n    function vaultData(address vault) external view returns (bool canPullFromIdle, uint64 penalty);\n\n    /* FUNCTIONS */\n\n    function multicall(bytes[] calldata data) external;\n    function setIsActiveAdapter(address vault, address adapter, bool newIsActiveAdapter) external;\n    function setAbsoluteCap(address vault, address adapter, MarketParams calldata marketParams, uint256 newAbsoluteCap) external;\n    function setCanPullFromMarket(address vault, address adapter, MarketParams calldata marketParams, bool newCanPullFromMarket) external;\n    function setCanPullFromIdle(address vault, bool newCanPullFromIdle) external;\n    function setPenalty(address vault, uint64 newPenalty) external;\n    function reallocate(address vault, address deallocateAdapter, MarketParams calldata deallocateMarketParams, address allocateAdapter, MarketParams calldata allocateMarketParams, uint128 assets, uint64 penalty) external;\n    function allocateFromIdle(address vault, address adapter, MarketParams calldata marketParams, uint128 assets, uint64 penalty) external;\n}\n// forgefmt: disable-end\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":100000,"enabled":true},"evmVersion":"cancun","remappings":["solmate/=lib/bundler3/lib/permit2/lib/solmate/","@openzeppelin/contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/contracts/","bundler3/=lib/bundler3/","bundles/=lib/bundles/","ds-test/=lib/metamorpho-1.1/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/metamorpho-1.1/lib/erc4626-tests/","forge-gas-snapshot/=lib/bundler3/lib/permit2/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/morpho-blue/lib/halmos-cheatcodes/src/","metamorpho-1.1/=lib/metamorpho-1.1/","metamorpho-v1.1/=lib/vault-v2/lib/metamorpho-v1.1/","metamorpho/=lib/vault-v2/lib/metamorpho/","midnight/=lib/midnight/","morpho-blue-irm/=lib/morpho-blue-irm/src/","morpho-blue-oracles/=lib/morpho-blue-oracles/src/","morpho-blue/=lib/morpho-blue/","murky/=lib/universal-rewards-distributor/lib/murky/src/","openzeppelin-contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/","openzeppelin/=lib/universal-rewards-distributor/lib/openzeppelin-contracts/contracts/","permit2/=lib/bundler3/lib/permit2/","pre-liquidation/=lib/pre-liquidation/src/","public-allocator/=lib/public-allocator/src/","safe-smart-account/=lib/safe-smart-account/","universal-rewards-distributor/=lib/universal-rewards-distributor/src/","vault-v2-adapter-registries/=lib/vault-v2-adapter-registries/src/","vault-v2/=lib/vault-v2/"]},"name":"BluePublicAllocator","fullyQualifiedName":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},"abi":[{"type":"constructor","inputs":[{"name":"_vaultV2Factory","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AbsoluteCapExceeded","type":"error","inputs":[]},{"name":"CannotPullFromIdle","type":"error","inputs":[]},{"name":"CannotPullFromMarket","type":"error","inputs":[]},{"name":"InactiveAdapter","type":"error","inputs":[]},{"name":"IncorrectPenalty","type":"error","inputs":[]},{"name":"NoCode","type":"error","inputs":[]},{"name":"NotVaultV2","type":"error","inputs":[]},{"name":"PenaltyTooHigh","type":"error","inputs":[]},{"name":"TransferFromReturnedFalse","type":"error","inputs":[]},{"name":"TransferFromReverted","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"ZeroAbsoluteCap","type":"error","inputs":[]},{"name":"AllocateFromIdle","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"allocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"assets","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"penaltyAssets","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Reallocate","type":"event","inputs":[{"name":"sender","type":"address","indexed":false,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"deallocateAdapter","type":"address","indexed":false,"internalType":"address"},{"name":"deallocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"allocateAdapter","type":"address","indexed":false,"internalType":"address"},{"name":"allocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"assets","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"penaltyAssets","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SetAbsoluteCap","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"marketParams","type":"tuple","indexed":false,"components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"absoluteCap","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SetCanPullFromIdle","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"canPullFromIdle","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetCanPullFromMarket","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"marketParams","type":"tuple","indexed":false,"components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"canPullFromMarket","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsActiveAdapter","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":true,"internalType":"address"},{"name":"isActiveAdapter","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetPenalty","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"newPenalty","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"absoluteCap","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allocateFromIdle","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"assets","type":"uint128","internalType":"uint128"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"canPullFromMarket","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isActiveAdapter","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"reallocate","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"deallocateAdapter","type":"address","internalType":"address"},{"name":"deallocateMarketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"allocateAdapter","type":"address","internalType":"address"},{"name":"allocateMarketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"assets","type":"uint128","internalType":"uint128"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAbsoluteCap","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"newAbsoluteCap","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCanPullFromIdle","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newCanPullFromIdle","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCanPullFromMarket","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"newCanPullFromMarket","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsActiveAdapter","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"newIsActiveAdapter","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPenalty","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newPenalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vaultData","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"canPullFromIdle","type":"bool","internalType":"bool"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"vaultV2Factory","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_vaultV2Factory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AbsoluteCapExceeded","type":"error"},{"inputs":[],"name":"CannotPullFromIdle","type":"error"},{"inputs":[],"name":"CannotPullFromMarket","type":"error"},{"inputs":[],"name":"InactiveAdapter","type":"error"},{"inputs":[],"name":"IncorrectPenalty","type":"error"},{"inputs":[],"name":"NoCode","type":"error"},{"inputs":[],"name":"NotVaultV2","type":"error"},{"inputs":[],"name":"PenaltyTooHigh","type":"error"},{"inputs":[],"name":"TransferFromReturnedFalse","type":"error"},{"inputs":[],"name":"TransferFromReverted","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"ZeroAbsoluteCap","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"address","name":"adapter","type":"address"},{"indexed":true,"internalType":"bytes32","name":"allocateId","type":"bytes32"},{"indexed":false,"internalType":"uint128","name":"assets","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"penaltyAssets","type":"uint256"}],"name":"AllocateFromIdle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"address","name":"deallocateAdapter","type":"address"},{"indexed":true,"internalType":"bytes32","name":"deallocateId","type":"bytes32"},{"indexed":false,"internalType":"address","name":"allocateAdapter","type":"address"},{"indexed":true,"internalType":"bytes32","name":"allocateId","type":"bytes32"},{"indexed":false,"internalType":"uint128","name":"assets","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"penaltyAssets","type":"uint256"}],"name":"Reallocate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"address","name":"adapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"indexed":false,"internalType":"struct MarketParams","name":"marketParams","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"absoluteCap","type":"uint256"}],"name":"SetAbsoluteCap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"bool","name":"canPullFromIdle","type":"bool"}],"name":"SetCanPullFromIdle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"address","name":"adapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"indexed":false,"internalType":"struct MarketParams","name":"marketParams","type":"tuple"},{"indexed":false,"internalType":"bool","name":"canPullFromMarket","type":"bool"}],"name":"SetCanPullFromMarket","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":true,"internalType":"address","name":"adapter","type":"address"},{"indexed":false,"internalType":"bool","name":"isActiveAdapter","type":"bool"}],"name":"SetIsActiveAdapter","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"uint64","name":"newPenalty","type":"uint64"}],"name":"SetPenalty","type":"event"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"absoluteCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"adapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"internalType":"struct MarketParams","name":"marketParams","type":"tuple"},{"internalType":"uint128","name":"assets","type":"uint128"},{"internalType":"uint64","name":"penalty","type":"uint64"}],"name":"allocateFromIdle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"canPullFromMarket","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"adapter","type":"address"}],"name":"isActiveAdapter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"deallocateAdapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"internalType":"struct MarketParams","name":"deallocateMarketParams","type":"tuple"},{"internalType":"address","name":"allocateAdapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"internalType":"struct MarketParams","name":"allocateMarketParams","type":"tuple"},{"internalType":"uint128","name":"assets","type":"uint128"},{"internalType":"uint64","name":"penalty","type":"uint64"}],"name":"reallocate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"adapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"internalType":"struct MarketParams","name":"marketParams","type":"tuple"},{"internalType":"uint256","name":"newAbsoluteCap","type":"uint256"}],"name":"setAbsoluteCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bool","name":"newCanPullFromIdle","type":"bool"}],"name":"setCanPullFromIdle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"adapter","type":"address"},{"components":[{"internalType":"address","name":"loanToken","type":"address"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"irm","type":"address"},{"internalType":"uint256","name":"lltv","type":"uint256"}],"internalType":"struct MarketParams","name":"marketParams","type":"tuple"},{"internalType":"bool","name":"newCanPullFromMarket","type":"bool"}],"name":"setCanPullFromMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"adapter","type":"address"},{"internalType":"bool","name":"newIsActiveAdapter","type":"bool"}],"name":"setIsActiveAdapter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"uint64","name":"newPenalty","type":"uint64"}],"name":"setPenalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"vaultData","outputs":[{"internalType":"bool","name":"canPullFromIdle","type":"bool"},{"internalType":"uint64","name":"penalty","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vaultV2Factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"devdoc":{"details":"To be usable, the BluePublicAllocator must be set as an allocator of the vault.Meant to be used with VaultV2 vaults only.Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system could break.The vault's allocators can manage the public allocators' settings.Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which increases the rate like forceDeallocate penalties).The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between signing and execution.The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.The public allocator's caps are not checked on allocations from the vault (either by allocators or through deposits).The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but it requires capital).reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.Reallocations (notably through this contract) can reduce the vault's \"direct\" liquidity by pulling assets from idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.","kind":"dev","methods":{"multicall(bytes[])":{"details":"Useful for EOAs to batch allocator calls.Does not return anything, because accounts who would use the return data would be contracts, which can do the multicall themselves."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":"BluePublicAllocator"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":100000},"remappings":[":@openzeppelin/contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/contracts/",":bundler3/=lib/bundler3/",":bundles/=lib/bundles/",":ds-test/=lib/metamorpho-1.1/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/metamorpho-1.1/lib/erc4626-tests/",":forge-gas-snapshot/=lib/bundler3/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/morpho-blue/lib/halmos-cheatcodes/src/",":metamorpho-1.1/=lib/metamorpho-1.1/",":metamorpho-v1.1/=lib/vault-v2/lib/metamorpho-v1.1/",":metamorpho/=lib/vault-v2/lib/metamorpho/",":midnight/=lib/midnight/",":morpho-blue-irm/=lib/morpho-blue-irm/src/",":morpho-blue-oracles/=lib/morpho-blue-oracles/src/",":morpho-blue/=lib/morpho-blue/",":murky/=lib/universal-rewards-distributor/lib/murky/src/",":openzeppelin-contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/",":openzeppelin/=lib/universal-rewards-distributor/lib/openzeppelin-contracts/contracts/",":permit2/=lib/bundler3/lib/permit2/",":pre-liquidation/=lib/pre-liquidation/src/",":public-allocator/=lib/public-allocator/src/",":safe-smart-account/=lib/safe-smart-account/",":solmate/=lib/bundler3/lib/permit2/lib/solmate/",":universal-rewards-distributor/=lib/universal-rewards-distributor/src/",":vault-v2-adapter-registries/=lib/vault-v2-adapter-registries/src/",":vault-v2/=lib/vault-v2/"],"viaIR":true},"sources":{"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol":{"keccak256":"0x5c50a9c93ea7d6c21472f68be7e32404d0cc5637b8df14994ddf9c87ef507afa","license":"GPL-2.0-or-later","urls":["bzz-raw://a63a40b090f74cbf96c7a67872110085d494bdeec8818372d53fd8cae0fec893","dweb:/ipfs/QmYR9n9tYHY1DrpGHMSNDggbsYBbMPs44Cbs7Rwh8vK2Qn"]},"lib/vault-v2/src/interfaces/IERC20.sol":{"keccak256":"0x4e66403784cf08fa5b5dc072b0ddb5a168dd69e8c3cdb912eed37e7da43f32a7","license":"GPL-2.0-or-later","urls":["bzz-raw://b67ef4141949be81dc2176a28334430687013f142ccc22f62b569a0cb90abd14","dweb:/ipfs/QmNsfyx5cGaDjWoMJiPdLnNwBvCk1PqBcKYqL935aUDemu"]},"lib/vault-v2/src/interfaces/IERC2612.sol":{"keccak256":"0x8a6a5882a5ade43ae94e7406251df9911a782f34ad723df857c8a2d8764a77fe","license":"GPL-2.0-or-later","urls":["bzz-raw://12767619d08b112738bed4f6d6df29771730ca65f52c64edb9854a0c19af1c82","dweb:/ipfs/QmeqUTxqRfRz6UQkbqJaRMAmL9D4eSPDeARYhSKxR9gZNt"]},"lib/vault-v2/src/interfaces/IERC4626.sol":{"keccak256":"0x49085f03fc0d7bd727b2c3cc1ae3e5b975f8a863011ec8fda293b613c611a7c3","license":"GPL-2.0-or-later","urls":["bzz-raw://38c86fc0c3d21190aec87f79009d24849170b66f411209e106cc279e8164c425","dweb:/ipfs/QmRNQMWnoebdj3wq77NxSsYAJpDTjdFFKi3ASXHe74yvYq"]},"lib/vault-v2/src/interfaces/IVaultV2.sol":{"keccak256":"0xd2e10276f2e354162ee695eb0700f2567b4e0e635bc03b5a669aa4ac78b15633","license":"GPL-2.0-or-later","urls":["bzz-raw://12c80ecbac96d303dd09714c411751a4241278a0c758af3906d19a50203ee602","dweb:/ipfs/QmP8BEViY32ndKGSameP83xcJhUw83NBVjrZRVbMqWDi48"]},"lib/vault-v2/src/interfaces/IVaultV2Factory.sol":{"keccak256":"0x1b5dbe5ef07cf9d3cccf8ad823e47f50abbc5a605b8183d81c90cd052dec438e","license":"GPL-2.0-or-later","urls":["bzz-raw://8cb7483a9d84185ca8eeccaaf30375510238bd41517777b164568c23542f5297","dweb:/ipfs/QmYVyGTKSLqjpnb7qR25fdFf6s1uLszg529dcciYjmaK84"]},"lib/vault-v2/src/libraries/ConstantsLib.sol":{"keccak256":"0xbe50152193f26320f4ced8deb26e8cede70d08164ef33a33599c9edf2b3c8898","license":"GPL-2.0-or-later","urls":["bzz-raw://d915b6a9060f16899ccbe5713211cb15930ede56d8bdea835485826239b99c6d","dweb:/ipfs/Qma1522ndLixZh4jYMcqgpXyZqiJWk2aD8NNUViy4gJ2p7"]},"lib/vault-v2/src/libraries/ErrorsLib.sol":{"keccak256":"0xd339b9f13a8adaaa8313ec5f1e0450a60c1f23b2d45ac4efbd4d93898efbff3f","license":"GPL-2.0-or-later","urls":["bzz-raw://0dd317e65dac6d40396cd51984bb53880ce9e1ea4a38d69ca19d9cd9f49d995c","dweb:/ipfs/QmdpD5piXTmPgAfcux6EeYuMP81zJf6x5c5rJpfNy5HyZK"]},"lib/vault-v2/src/libraries/MathLib.sol":{"keccak256":"0x67d6eaa5d36502665f6527e9468af49be20b56aa1a4abab8ca49f50add0d2436","license":"GPL-2.0-or-later","urls":["bzz-raw://5b1b5c98d93c681b91385c248a2287def1c0809ffcc807d44417d826ccdd2336","dweb:/ipfs/QmVA2YbLk5nKw8G7LH7mvxydpQUqaxrfffadvF8b7ZH7Gu"]},"lib/vault-v2/src/libraries/SafeERC20Lib.sol":{"keccak256":"0xfa2011ae673cdf3f5f7e2c3c2596e30ac6fb1b8ad006d8d88c128e1165245d9c","license":"GPL-2.0-or-later","urls":["bzz-raw://f6f44b235cc3990462dd4ed9bb13b02c03bd50fe352cef7d2c926b3e0f7180f6","dweb:/ipfs/QmWkJmmoEWVgsjULi1eYUAgfkVWXiMzJS99AT1JaoVFpm2"]},"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"keccak256":"0x2bbfadb1914ce4735f54752ce2215037121a5765f3495caa72d1fc03d910b5e6","license":"GPL-2.0-or-later","urls":["bzz-raw://5e91ba581d13ee4f57cff4ebf85b37170ae796952775e8ecbec6d2b1829e157c","dweb:/ipfs/QmZmNHG9M5bzD1SkMuYnrX23BFoCLaQXwztbFLjvXZqjAn"]},"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol":{"keccak256":"0x91308d2623789a6d786a4729dd91471981d8a3ef742fd0f94ce243daa410caaa","license":"GPL-2.0-or-later","urls":["bzz-raw://02bee0e11f9f3771673fa3f5a25ca4ae495daf1d82c3775cd59bd0c66a92c8f7","dweb:/ipfs/QmVSSEhsKoprUkMn9GV4EMP5fAYa4EUc6NJZ9mgZbBCQox"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint64":{"label":"uint64","encoding":"inplace","numberOfBytes":"8"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_bool)":{"key":"t_bytes32","label":"mapping(bytes32 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_uint256)":{"key":"t_bytes32","label":"mapping(bytes32 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(VaultData)2225_storage":{"label":"struct VaultData","members":[{"slot":"0","type":"t_bool","astId":2222,"label":"canPullFromIdle","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"0","type":"t_uint64","astId":2224,"label":"penalty","offset":1,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes32,t_bool))":{"key":"t_address","label":"mapping(address => mapping(bytes32 => bool))","value":"t_mapping(t_bytes32,t_bool)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes32,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(bytes32 => uint256))","value":"t_mapping(t_bytes32,t_uint256)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(VaultData)2225_storage)":{"key":"t_address","label":"mapping(address => struct VaultData)","value":"t_struct(VaultData)2225_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_mapping(t_bytes32,t_uint256))","astId":1572,"label":"absoluteCap","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_bytes32,t_bool))","astId":1578,"label":"canPullFromMarket","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":1584,"label":"isActiveAdapter","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"3","type":"t_mapping(t_address,t_struct(VaultData)2225_storage)","astId":1589,"label":"vaultData","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","details":"To be usable, the BluePublicAllocator must be set as an allocator of the vault.Meant to be used with VaultV2 vaults only.Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system could break.The vault's allocators can manage the public allocators' settings.Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which increases the rate like forceDeallocate penalties).The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between signing and execution.The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.The public allocator's caps are not checked on allocations from the vault (either by allocators or through deposits).The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but it requires capital).reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.Reallocations (notably through this contract) can reduce the vault's \"direct\" liquidity by pulling assets from idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.","methods":{"multicall(bytes[])":{"details":"Useful for EOAs to batch allocator calls.Does not return anything, because accounts who would use the return data would be contracts, which can do the multicall themselves."}},"version":1},"sourceIds":{"lib/vault-v2/src/interfaces/IERC20.sol":{"id":1},"lib/vault-v2/src/libraries/MathLib.sol":{"id":8},"lib/vault-v2/src/interfaces/IERC2612.sol":{"id":2},"lib/vault-v2/src/interfaces/IERC4626.sol":{"id":3},"lib/vault-v2/src/interfaces/IVaultV2.sol":{"id":4},"lib/vault-v2/src/libraries/ErrorsLib.sol":{"id":7},"lib/vault-v2/src/libraries/ConstantsLib.sol":{"id":6},"lib/vault-v2/src/libraries/SafeERC20Lib.sol":{"id":9},"lib/vault-v2/src/interfaces/IVaultV2Factory.sol":{"id":5},"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol":{"id":0},"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"id":10},"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol":{"id":11}},"additionalInput":null,"stdJsonInput":{"sources":{"lib/vault-v2/src/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IERC20 {\n    function decimals() external view returns (uint8);\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function totalSupply() external view returns (uint256);\n    function balanceOf(address account) external view returns (uint256);\n    function transfer(address to, uint256 shares) external returns (bool success);\n    function transferFrom(address from, address to, uint256 shares) external returns (bool success);\n    function approve(address spender, uint256 shares) external returns (bool success);\n    function allowance(address owner, address spender) external view returns (uint256);\n}\n"},"lib/vault-v2/src/libraries/MathLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nimport {ErrorsLib} from \"./ErrorsLib.sol\";\n\nlibrary MathLib {\n    /// @dev Returns (x * y) / d rounded down.\n    function mulDivDown(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {\n        return (x * y) / d;\n    }\n\n    /// @dev Returns (x * y) / d rounded up.\n    function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {\n        return (x * y + (d - 1)) / d;\n    }\n\n    /// @dev Returns max(0, x - y).\n    function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {\n        assembly {\n            z := mul(gt(x, y), sub(x, y))\n        }\n    }\n\n    /// @dev Casts from uint256 to uint128, reverting if input number is too large.\n    function toUint128(uint256 x) internal pure returns (uint128) {\n        require(x <= type(uint128).max, ErrorsLib.CastOverflow());\n        // forge-lint: disable-next-item(unsafe-typecast) safe because x <= type(uint128).max.\n        return uint128(x);\n    }\n\n    /// @dev Casts from int256 to uint256, reverting if input number is negative.\n    function toUint256(int256 x) internal pure returns (uint256) {\n        require(x >= 0, ErrorsLib.CastOverflow());\n        // forge-lint: disable-next-item(unsafe-typecast) safe because x >= 0.\n        return uint256(x);\n    }\n\n    /// @dev Returns min(x, y).\n    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {\n        assembly {\n            z := xor(x, mul(xor(x, y), lt(y, x)))\n        }\n    }\n}\n"},"lib/vault-v2/src/interfaces/IERC2612.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IERC2612 {\n    function permit(address owner, address spender, uint256 shares, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n        external;\n    function nonces(address owner) external view returns (uint256);\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"lib/vault-v2/src/interfaces/IERC4626.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\nimport {IERC20} from \"./IERC20.sol\";\n\ninterface IERC4626 is IERC20 {\n    function asset() external view returns (address);\n    function totalAssets() external view returns (uint256);\n    function convertToAssets(uint256 shares) external view returns (uint256 assets);\n    function convertToShares(uint256 assets) external view returns (uint256 shares);\n    function deposit(uint256 assets, address onBehalf) external returns (uint256 shares);\n    function mint(uint256 shares, address onBehalf) external returns (uint256 assets);\n    function withdraw(uint256 assets, address receiver, address onBehalf) external returns (uint256 shares);\n    function redeem(uint256 shares, address receiver, address onBehalf) external returns (uint256 assets);\n    function previewDeposit(uint256 assets) external view returns (uint256 shares);\n    function previewMint(uint256 shares) external view returns (uint256 assets);\n    function previewWithdraw(uint256 assets) external view returns (uint256 shares);\n    function previewRedeem(uint256 shares) external view returns (uint256 assets);\n    function maxDeposit(address onBehalf) external view returns (uint256 assets);\n    function maxMint(address onBehalf) external view returns (uint256 shares);\n    function maxWithdraw(address onBehalf) external view returns (uint256 assets);\n    function maxRedeem(address onBehalf) external view returns (uint256 shares);\n}\n"},"lib/vault-v2/src/interfaces/IVaultV2.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\nimport {IERC4626} from \"./IERC4626.sol\";\nimport {IERC2612} from \"./IERC2612.sol\";\n\nstruct Caps {\n    uint256 allocation;\n    uint128 absoluteCap;\n    uint128 relativeCap;\n}\n\ninterface IVaultV2 is IERC4626, IERC2612 {\n    // State variables\n    function virtualShares() external view returns (uint256);\n    function owner() external view returns (address);\n    function curator() external view returns (address);\n    function receiveSharesGate() external view returns (address);\n    function sendSharesGate() external view returns (address);\n    function receiveAssetsGate() external view returns (address);\n    function sendAssetsGate() external view returns (address);\n    function adapterRegistry() external view returns (address);\n    function isSentinel(address account) external view returns (bool);\n    function isAllocator(address account) external view returns (bool);\n    function firstTotalAssets() external view returns (uint256);\n    function _totalAssets() external view returns (uint128);\n    function lastUpdate() external view returns (uint64);\n    function maxRate() external view returns (uint64);\n    function adapters(uint256 index) external view returns (address);\n    function adaptersLength() external view returns (uint256);\n    function isAdapter(address account) external view returns (bool);\n    function allocation(bytes32 id) external view returns (uint256);\n    function absoluteCap(bytes32 id) external view returns (uint256);\n    function relativeCap(bytes32 id) external view returns (uint256);\n    function forceDeallocatePenalty(address adapter) external view returns (uint256);\n    function liquidityAdapter() external view returns (address);\n    function liquidityData() external view returns (bytes memory);\n    function timelock(bytes4 selector) external view returns (uint256);\n    function abdicated(bytes4 selector) external view returns (bool);\n    function executableAt(bytes memory data) external view returns (uint256);\n    function performanceFee() external view returns (uint96);\n    function performanceFeeRecipient() external view returns (address);\n    function managementFee() external view returns (uint96);\n    function managementFeeRecipient() external view returns (address);\n\n    // Gating\n    function canSendShares(address account) external view returns (bool);\n    function canReceiveShares(address account) external view returns (bool);\n    function canSendAssets(address account) external view returns (bool);\n    function canReceiveAssets(address account) external view returns (bool);\n\n    // Multicall\n    function multicall(bytes[] memory data) external;\n\n    // Owner functions\n    function setOwner(address newOwner) external;\n    function setCurator(address newCurator) external;\n    function setIsSentinel(address account, bool isSentinel) external;\n    function setName(string memory newName) external;\n    function setSymbol(string memory newSymbol) external;\n\n    // Timelocks for curator functions\n    function submit(bytes memory data) external;\n    function revoke(bytes memory data) external;\n\n    // Curator functions\n    function setIsAllocator(address account, bool newIsAllocator) external;\n    function setReceiveSharesGate(address newReceiveSharesGate) external;\n    function setSendSharesGate(address newSendSharesGate) external;\n    function setReceiveAssetsGate(address newReceiveAssetsGate) external;\n    function setSendAssetsGate(address newSendAssetsGate) external;\n    function setAdapterRegistry(address newAdapterRegistry) external;\n    function addAdapter(address account) external;\n    function removeAdapter(address account) external;\n    function increaseTimelock(bytes4 selector, uint256 newDuration) external;\n    function decreaseTimelock(bytes4 selector, uint256 newDuration) external;\n    function abdicate(bytes4 selector) external;\n    function setPerformanceFee(uint256 newPerformanceFee) external;\n    function setManagementFee(uint256 newManagementFee) external;\n    function setPerformanceFeeRecipient(address newPerformanceFeeRecipient) external;\n    function setManagementFeeRecipient(address newManagementFeeRecipient) external;\n    function increaseAbsoluteCap(bytes memory idData, uint256 newAbsoluteCap) external;\n    function decreaseAbsoluteCap(bytes memory idData, uint256 newAbsoluteCap) external;\n    function increaseRelativeCap(bytes memory idData, uint256 newRelativeCap) external;\n    function decreaseRelativeCap(bytes memory idData, uint256 newRelativeCap) external;\n    function setMaxRate(uint256 newMaxRate) external;\n    function setForceDeallocatePenalty(address adapter, uint256 newForceDeallocatePenalty) external;\n\n    // Allocator functions\n    function allocate(address adapter, bytes memory data, uint256 assets) external;\n    function deallocate(address adapter, bytes memory data, uint256 assets) external;\n    function setLiquidityAdapterAndData(address newLiquidityAdapter, bytes memory newLiquidityData) external;\n\n    // Exchange rate\n    function accrueInterest() external;\n    function accrueInterestView()\n        external\n        view\n        returns (uint256 newTotalAssets, uint256 performanceFeeShares, uint256 managementFeeShares);\n\n    // Force deallocate\n    function forceDeallocate(address adapter, bytes memory data, uint256 assets, address onBehalf)\n        external\n        returns (uint256 penaltyShares);\n}\n"},"lib/vault-v2/src/libraries/ErrorsLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nlibrary ErrorsLib {\n    error Abdicated();\n    error AbsoluteCapExceeded();\n    error AbsoluteCapNotDecreasing();\n    error AbsoluteCapNotIncreasing();\n    error ApproveReturnedFalse();\n    error ApproveReverted();\n    error AutomaticallyTimelocked();\n    error CannotReceiveShares();\n    error CannotReceiveAssets();\n    error CannotSendShares();\n    error CannotSendAssets();\n    error CapExceeded();\n    error CastOverflow();\n    error DataAlreadyPending();\n    error DataNotTimelocked();\n    error FeeInvariantBroken();\n    error FeeTooHigh();\n    error InvalidSigner();\n    error MaxRateTooHigh();\n    error NoCode();\n    error NotAdapter();\n    error NotInAdapterRegistry();\n    error PenaltyTooHigh();\n    error PermitDeadlineExpired();\n    error RelativeCapAboveOne();\n    error RelativeCapExceeded();\n    error RelativeCapNotDecreasing();\n    error RelativeCapNotIncreasing();\n    error TimelockNotDecreasing();\n    error TimelockNotExpired();\n    error TimelockNotIncreasing();\n    error TransferFromReturnedFalse();\n    error TransferFromReverted();\n    error TransferReturnedFalse();\n    error TransferReverted();\n    error Unauthorized();\n    error ZeroAbsoluteCap();\n    error ZeroAddress();\n    error ZeroAllocation();\n}\n"},"lib/vault-v2/src/libraries/ConstantsLib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nuint256 constant WAD = 1e18;\nbytes32 constant DOMAIN_TYPEHASH = keccak256(\"EIP712Domain(uint256 chainId,address verifyingContract)\");\nbytes32 constant PERMIT_TYPEHASH =\n    keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\nuint256 constant MAX_MAX_RATE = 200e16 / uint256(365 days); // 200% APR\nuint256 constant MAX_PERFORMANCE_FEE = 0.5e18; // 50%\nuint256 constant MAX_MANAGEMENT_FEE = 0.05e18 / uint256(365 days); // 5%\nuint256 constant MAX_FORCE_DEALLOCATE_PENALTY = 0.02e18; // 2%\n"},"lib/vault-v2/src/libraries/SafeERC20Lib.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity ^0.8.0;\n\nimport {IERC20} from \"../interfaces/IERC20.sol\";\nimport {ErrorsLib} from \"./ErrorsLib.sol\";\n\nlibrary SafeERC20Lib {\n    function safeTransfer(address token, address to, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.transfer, (to, value)));\n        require(success, ErrorsLib.TransferReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.TransferReturnedFalse());\n    }\n\n    function safeTransferFrom(address token, address from, address to, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.transferFrom, (from, to, value)));\n        require(success, ErrorsLib.TransferFromReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.TransferFromReturnedFalse());\n    }\n\n    function safeApprove(address token, address spender, uint256 value) internal {\n        require(token.code.length > 0, ErrorsLib.NoCode());\n\n        (bool success, bytes memory returndata) = token.call(abi.encodeCall(IERC20.approve, (spender, value)));\n        require(success, ErrorsLib.ApproveReverted());\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), ErrorsLib.ApproveReturnedFalse());\n    }\n}\n"},"lib/vault-v2/src/interfaces/IVaultV2Factory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2025 Morpho Association\npragma solidity >=0.5.0;\n\ninterface IVaultV2Factory {\n    /* EVENTS */\n\n    event CreateVaultV2(address indexed owner, address indexed asset, bytes32 salt, address indexed newVaultV2);\n\n    /* FUNCTIONS */\n\n    function isVaultV2(address account) external view returns (bool);\n    function vaultV2(address owner, address asset, bytes32 salt) external view returns (address);\n    function createVaultV2(address owner, address asset, bytes32 salt) external returns (address newVaultV2);\n}\n"},"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\ntype Id is bytes32;\n\nstruct MarketParams {\n    address loanToken;\n    address collateralToken;\n    address oracle;\n    address irm;\n    uint256 lltv;\n}\n\n/// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest\n/// accrual.\nstruct Position {\n    uint256 supplyShares;\n    uint128 borrowShares;\n    uint128 collateral;\n}\n\n/// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n/// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n/// @dev Warning: `totalSupplyShares` does not contain the additional shares accrued by `feeRecipient` since the last\n/// interest accrual.\nstruct Market {\n    uint128 totalSupplyAssets;\n    uint128 totalSupplyShares;\n    uint128 totalBorrowAssets;\n    uint128 totalBorrowShares;\n    uint128 lastUpdate;\n    uint128 fee;\n}\n\nstruct Authorization {\n    address authorizer;\n    address authorized;\n    bool isAuthorized;\n    uint256 nonce;\n    uint256 deadline;\n}\n\nstruct Signature {\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n}\n\n/// @dev This interface is used for factorizing IMorphoStaticTyping and IMorpho.\n/// @dev Consider using the IMorpho interface instead of this one.\ninterface IMorphoBase {\n    /// @notice The EIP-712 domain separator.\n    /// @dev Warning: Every EIP-712 signed message based on this domain separator can be reused on chains sharing the\n    /// same chain id and on forks because the domain separator would be the same.\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n    /// @notice The owner of the contract.\n    /// @dev It has the power to change the owner.\n    /// @dev It has the power to set fees on markets and set the fee recipient.\n    /// @dev It has the power to enable but not disable IRMs and LLTVs.\n    function owner() external view returns (address);\n\n    /// @notice The fee recipient of all markets.\n    /// @dev The recipient receives the fees of a given market through a supply position on that market.\n    function feeRecipient() external view returns (address);\n\n    /// @notice Whether the `irm` is enabled.\n    function isIrmEnabled(address irm) external view returns (bool);\n\n    /// @notice Whether the `lltv` is enabled.\n    function isLltvEnabled(uint256 lltv) external view returns (bool);\n\n    /// @notice Whether `authorized` is authorized to modify `authorizer`'s position on all markets.\n    /// @dev Anyone is authorized to modify their own positions, regardless of this variable.\n    function isAuthorized(address authorizer, address authorized) external view returns (bool);\n\n    /// @notice The `authorizer`'s current nonce. Used to prevent replay attacks with EIP-712 signatures.\n    function nonce(address authorizer) external view returns (uint256);\n\n    /// @notice Sets `newOwner` as `owner` of the contract.\n    /// @dev Warning: No two-step transfer ownership.\n    /// @dev Warning: The owner can be set to the zero address.\n    function setOwner(address newOwner) external;\n\n    /// @notice Enables `irm` as a possible IRM for market creation.\n    /// @dev Warning: It is not possible to disable an IRM.\n    function enableIrm(address irm) external;\n\n    /// @notice Enables `lltv` as a possible LLTV for market creation.\n    /// @dev Warning: It is not possible to disable a LLTV.\n    function enableLltv(uint256 lltv) external;\n\n    /// @notice Sets the `newFee` for the given market `marketParams`.\n    /// @param newFee The new fee, scaled by WAD.\n    /// @dev Warning: The recipient can be the zero address.\n    function setFee(MarketParams memory marketParams, uint256 newFee) external;\n\n    /// @notice Sets `newFeeRecipient` as `feeRecipient` of the fee.\n    /// @dev Warning: If the fee recipient is set to the zero address, fees will accrue there and will be lost.\n    /// @dev Modifying the fee recipient will allow the new recipient to claim any pending fees not yet accrued. To\n    /// ensure that the current recipient receives all due fees, accrue interest manually prior to making any changes.\n    function setFeeRecipient(address newFeeRecipient) external;\n\n    /// @notice Creates the market `marketParams`.\n    /// @dev Here is the list of assumptions on the market's dependencies (tokens, IRM and oracle) that guarantees\n    /// Morpho behaves as expected:\n    /// - The token should be ERC-20 compliant, except that it can omit return values on `transfer` and `transferFrom`.\n    /// - The token balance of Morpho should only decrease on `transfer` and `transferFrom`. In particular, tokens with\n    /// burn functions are not supported.\n    /// - The token should not re-enter Morpho on `transfer` nor `transferFrom`.\n    /// - The token balance of the sender (resp. receiver) should decrease (resp. increase) by exactly the given amount\n    /// on `transfer` and `transferFrom`. In particular, tokens with fees on transfer are not supported.\n    /// - The IRM should not re-enter Morpho.\n    /// - The oracle should return a price with the correct scaling.\n    /// - The oracle price should not be able to change instantly such that the new price is less than the old price\n    /// multiplied by LLTV*LIF. In particular, if the loan asset is a vault that can receive donations, the oracle\n    /// should not price its shares using the AUM.\n    /// @dev Here is a list of assumptions on the market's dependencies which, if broken, could break Morpho's liveness\n    /// properties (funds could get stuck):\n    /// - The token should not revert on `transfer` and `transferFrom` if balances and approvals are right.\n    /// - The amount of assets supplied and borrowed should not be too high (max ~1e32), otherwise the number of shares\n    /// might not fit within 128 bits.\n    /// - The IRM should not revert on `borrowRate`.\n    /// - The IRM should not return a very high borrow rate (otherwise the computation of `interest` in\n    /// `_accrueInterest` can overflow).\n    /// - The oracle should not revert `price`.\n    /// - The oracle should not return a very high price (otherwise the computation of `maxBorrow` in `_isHealthy` or of\n    /// `assetsRepaid` in `liquidate` can overflow).\n    /// @dev The borrow share price of a market with less than 1e4 assets borrowed can be decreased by manipulations, to\n    /// the point where `totalBorrowShares` is very large and borrowing overflows.\n    function createMarket(MarketParams memory marketParams) external;\n\n    /// @notice Supplies `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoSupply` function with the given `data`.\n    /// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the\n    /// caller is guaranteed to have `assets` tokens pulled from their balance, but the possibility to mint a specific\n    /// amount of shares is given for full compatibility and precision.\n    /// @dev Supplying a large amount can revert for overflow.\n    /// @dev Supplying an amount of shares may lead to supply more or fewer assets than expected due to slippage.\n    /// Consider using the `assets` parameter to avoid this.\n    /// @param marketParams The market to supply assets to.\n    /// @param assets The amount of assets to supply.\n    /// @param shares The amount of shares to mint.\n    /// @param onBehalf The address that will own the increased supply position.\n    /// @param data Arbitrary data to pass to the `onMorphoSupply` callback. Pass empty data if not needed.\n    /// @return assetsSupplied The amount of assets supplied.\n    /// @return sharesSupplied The amount of shares minted.\n    function supply(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        bytes memory data\n    ) external returns (uint256 assetsSupplied, uint256 sharesSupplied);\n\n    /// @notice Withdraws `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev Either `assets` or `shares` should be zero. To withdraw max, pass the `shares`'s balance of `onBehalf`.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Withdrawing an amount corresponding to more shares than supplied will revert for underflow.\n    /// @dev It is advised to use the `shares` input when withdrawing the full position to avoid reverts due to\n    /// conversion roundings between shares and assets.\n    /// @param marketParams The market to withdraw assets from.\n    /// @param assets The amount of assets to withdraw.\n    /// @param shares The amount of shares to burn.\n    /// @param onBehalf The address of the owner of the supply position.\n    /// @param receiver The address that will receive the withdrawn assets.\n    /// @return assetsWithdrawn The amount of assets withdrawn.\n    /// @return sharesWithdrawn The amount of shares burned.\n    function withdraw(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        address receiver\n    ) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn);\n\n    /// @notice Borrows `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the\n    /// caller is guaranteed to borrow `assets` of tokens, but the possibility to mint a specific amount of shares is\n    /// given for full compatibility and precision.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Borrowing a large amount can revert for overflow.\n    /// @dev Borrowing an amount of shares may lead to borrow fewer assets than expected due to slippage.\n    /// Consider using the `assets` parameter to avoid this.\n    /// @param marketParams The market to borrow assets from.\n    /// @param assets The amount of assets to borrow.\n    /// @param shares The amount of shares to mint.\n    /// @param onBehalf The address that will own the increased borrow position.\n    /// @param receiver The address that will receive the borrowed assets.\n    /// @return assetsBorrowed The amount of assets borrowed.\n    /// @return sharesBorrowed The amount of shares minted.\n    function borrow(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        address receiver\n    ) external returns (uint256 assetsBorrowed, uint256 sharesBorrowed);\n\n    /// @notice Repays `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoRepay` function with the given `data`.\n    /// @dev Either `assets` or `shares` should be zero. To repay max, pass the `shares`'s balance of `onBehalf`.\n    /// @dev Repaying an amount corresponding to more shares than borrowed will revert for underflow.\n    /// @dev It is advised to use the `shares` input when repaying the full position to avoid reverts due to conversion\n    /// roundings between shares and assets.\n    /// @dev An attacker can front-run a repay with a small repay making the transaction revert for underflow.\n    /// @param marketParams The market to repay assets to.\n    /// @param assets The amount of assets to repay.\n    /// @param shares The amount of shares to burn.\n    /// @param onBehalf The address of the owner of the debt position.\n    /// @param data Arbitrary data to pass to the `onMorphoRepay` callback. Pass empty data if not needed.\n    /// @return assetsRepaid The amount of assets repaid.\n    /// @return sharesRepaid The amount of shares burned.\n    function repay(\n        MarketParams memory marketParams,\n        uint256 assets,\n        uint256 shares,\n        address onBehalf,\n        bytes memory data\n    ) external returns (uint256 assetsRepaid, uint256 sharesRepaid);\n\n    /// @notice Supplies `assets` of collateral on behalf of `onBehalf`, optionally calling back the caller's\n    /// `onMorphoSupplyCollateral` function with the given `data`.\n    /// @dev Interest are not accrued since it's not required and it saves gas.\n    /// @dev Supplying a large amount can revert for overflow.\n    /// @param marketParams The market to supply collateral to.\n    /// @param assets The amount of collateral to supply.\n    /// @param onBehalf The address that will own the increased collateral position.\n    /// @param data Arbitrary data to pass to the `onMorphoSupplyCollateral` callback. Pass empty data if not needed.\n    function supplyCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, bytes memory data)\n        external;\n\n    /// @notice Withdraws `assets` of collateral on behalf of `onBehalf` and sends the assets to `receiver`.\n    /// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.\n    /// @dev Withdrawing an amount corresponding to more collateral than supplied will revert for underflow.\n    /// @param marketParams The market to withdraw collateral from.\n    /// @param assets The amount of collateral to withdraw.\n    /// @param onBehalf The address of the owner of the collateral position.\n    /// @param receiver The address that will receive the collateral assets.\n    function withdrawCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, address receiver)\n        external;\n\n    /// @notice Liquidates the given `repaidShares` of debt asset or seize the given `seizedAssets` of collateral on the\n    /// given market `marketParams` of the given `borrower`'s position, optionally calling back the caller's\n    /// `onMorphoLiquidate` function with the given `data`.\n    /// @dev Either `seizedAssets` or `repaidShares` should be zero.\n    /// @dev Seizing more than the collateral balance will underflow and revert without any error message.\n    /// @dev Repaying more than the borrow balance will underflow and revert without any error message.\n    /// @dev An attacker can front-run a liquidation with a small repay making the transaction revert for underflow.\n    /// @param marketParams The market of the position.\n    /// @param borrower The owner of the position.\n    /// @param seizedAssets The amount of collateral to seize.\n    /// @param repaidShares The amount of shares to repay.\n    /// @param data Arbitrary data to pass to the `onMorphoLiquidate` callback. Pass empty data if not needed.\n    /// @return The amount of assets seized.\n    /// @return The amount of assets repaid.\n    function liquidate(\n        MarketParams memory marketParams,\n        address borrower,\n        uint256 seizedAssets,\n        uint256 repaidShares,\n        bytes memory data\n    ) external returns (uint256, uint256);\n\n    /// @notice Executes a flash loan.\n    /// @dev Flash loans have access to the whole balance of the contract (the liquidity and deposited collateral of all\n    /// markets combined, plus donations).\n    /// @dev Warning: Not ERC-3156 compliant but compatibility is easily reached:\n    /// - `flashFee` is zero.\n    /// - `maxFlashLoan` is the token's balance of this contract.\n    /// - The receiver of `assets` is the caller.\n    /// @param token The token to flash loan.\n    /// @param assets The amount of assets to flash loan.\n    /// @param data Arbitrary data to pass to the `onMorphoFlashLoan` callback.\n    function flashLoan(address token, uint256 assets, bytes calldata data) external;\n\n    /// @notice Sets the authorization for `authorized` to manage `msg.sender`'s positions.\n    /// @param authorized The authorized address.\n    /// @param newIsAuthorized The new authorization status.\n    function setAuthorization(address authorized, bool newIsAuthorized) external;\n\n    /// @notice Sets the authorization for `authorization.authorized` to manage `authorization.authorizer`'s positions.\n    /// @dev Warning: Reverts if the signature has already been submitted.\n    /// @dev The signature is malleable, but it has no impact on the security here.\n    /// @dev The nonce is passed as argument to be able to revert with a different error message.\n    /// @param authorization The `Authorization` struct.\n    /// @param signature The signature.\n    function setAuthorizationWithSig(Authorization calldata authorization, Signature calldata signature) external;\n\n    /// @notice Accrues interest for the given market `marketParams`.\n    function accrueInterest(MarketParams memory marketParams) external;\n\n    /// @notice Returns the data stored on the different `slots`.\n    function extSloads(bytes32[] memory slots) external view returns (bytes32[] memory);\n}\n\n/// @dev This interface is inherited by Morpho so that function signatures are checked by the compiler.\n/// @dev Consider using the IMorpho interface instead of this one.\ninterface IMorphoStaticTyping is IMorphoBase {\n    /// @notice The state of the position of `user` on the market corresponding to `id`.\n    /// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest\n    /// accrual.\n    function position(Id id, address user)\n        external\n        view\n        returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral);\n\n    /// @notice The state of the market corresponding to `id`.\n    /// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last interest\n    /// accrual.\n    function market(Id id)\n        external\n        view\n        returns (\n            uint128 totalSupplyAssets,\n            uint128 totalSupplyShares,\n            uint128 totalBorrowAssets,\n            uint128 totalBorrowShares,\n            uint128 lastUpdate,\n            uint128 fee\n        );\n\n    /// @notice The market params corresponding to `id`.\n    /// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer\n    /// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.\n    function idToMarketParams(Id id)\n        external\n        view\n        returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv);\n}\n\n/// @title IMorpho\n/// @author Morpho Labs\n/// @custom:contact security@morpho.org\n/// @dev Use this interface for Morpho to have access to all the functions with the appropriate function signatures.\ninterface IMorpho is IMorphoBase {\n    /// @notice The state of the position of `user` on the market corresponding to `id`.\n    /// @dev Warning: For `feeRecipient`, `p.supplyShares` does not contain the accrued shares since the last interest\n    /// accrual.\n    function position(Id id, address user) external view returns (Position memory p);\n\n    /// @notice The state of the market corresponding to `id`.\n    /// @dev Warning: `m.totalSupplyAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `m.totalBorrowAssets` does not contain the accrued interest since the last interest accrual.\n    /// @dev Warning: `m.totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last\n    /// interest accrual.\n    function market(Id id) external view returns (Market memory m);\n\n    /// @notice The market params corresponding to `id`.\n    /// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer\n    /// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.\n    function idToMarketParams(Id id) external view returns (MarketParams memory);\n}\n"},"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2026 Morpho Association\npragma solidity 0.8.28;\n\nimport {IVaultV2} from \"../../interfaces/IVaultV2.sol\";\nimport {IVaultV2Factory} from \"../../interfaces/IVaultV2Factory.sol\";\nimport {IBluePublicAllocator, VaultData} from \"./interfaces/IBluePublicAllocator.sol\";\nimport {MarketParams} from \"../../../lib/morpho-blue/src/interfaces/IMorpho.sol\";\nimport {WAD} from \"../../libraries/ConstantsLib.sol\";\nimport {MathLib} from \"../../libraries/MathLib.sol\";\nimport {SafeERC20Lib} from \"../../libraries/SafeERC20Lib.sol\";\n\n/// @dev To be usable, the BluePublicAllocator must be set as an allocator of the vault.\n/// @dev Meant to be used with VaultV2 vaults only.\n/// @dev Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system\n/// could break.\n/// @dev The vault's allocators can manage the public allocators' settings.\n/// @dev Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's\n/// asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which\n/// increases the rate like forceDeallocate penalties).\n/// @dev The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between\n/// signing and execution.\n/// @dev The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.\n/// @dev The public allocator's caps are not checked on allocations from the vault (either by allocators or through\n/// deposits).\n/// @dev The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but\n/// it requires capital).\n/// @dev reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an\n/// allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.\n/// @dev Reallocations (notably through this contract) can reduce the vault's \"direct\" liquidity by pulling assets from\n/// idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.\ncontract BluePublicAllocator is IBluePublicAllocator {\n    /* IMMUTABLES */\n\n    address public immutable vaultV2Factory;\n\n    /* STORAGE */\n\n    mapping(address vault => mapping(bytes32 id => uint256)) public absoluteCap;\n    mapping(address vault => mapping(bytes32 id => bool)) public canPullFromMarket;\n    mapping(address vault => mapping(address adapter => bool)) public isActiveAdapter;\n    mapping(address vault => VaultData) public vaultData;\n\n    /* CONSTRUCTOR */\n\n    constructor(address _vaultV2Factory) {\n        vaultV2Factory = _vaultV2Factory;\n    }\n\n    /* MULTICALL */\n\n    /// @dev Useful for EOAs to batch allocator calls.\n    /// @dev Does not return anything, because accounts who would use the return data would be contracts, which can do\n    /// the multicall themselves.\n    function multicall(bytes[] calldata data) external {\n        for (uint256 i = 0; i < data.length; i++) {\n            (bool success, bytes memory returnData) = address(this).delegatecall(data[i]);\n            if (!success) {\n                assembly (\"memory-safe\") {\n                    revert(add(32, returnData), mload(returnData))\n                }\n            }\n        }\n    }\n\n    /* AUTHORIZED FUNCTIONS */\n\n    function setIsActiveAdapter(address vault, address adapter, bool newIsActiveAdapter) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        isActiveAdapter[vault][adapter] = newIsActiveAdapter;\n        emit SetIsActiveAdapter(msg.sender, vault, adapter, newIsActiveAdapter);\n    }\n\n    function setAbsoluteCap(address vault, address adapter, MarketParams calldata marketParams, uint256 newAbsoluteCap)\n        external\n    {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        bytes32 id = vaultBlueId(adapter, marketParams);\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        absoluteCap[vault][id] = newAbsoluteCap;\n        emit SetAbsoluteCap(msg.sender, vault, adapter, marketParams, newAbsoluteCap);\n    }\n\n    function setCanPullFromMarket(\n        address vault,\n        address adapter,\n        MarketParams calldata marketParams,\n        bool newCanPullFromMarket\n    ) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        canPullFromMarket[vault][vaultBlueId(adapter, marketParams)] = newCanPullFromMarket;\n        emit SetCanPullFromMarket(msg.sender, vault, adapter, marketParams, newCanPullFromMarket);\n    }\n\n    function setCanPullFromIdle(address vault, bool newCanPullFromIdle) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        vaultData[vault].canPullFromIdle = newCanPullFromIdle;\n        emit SetCanPullFromIdle(msg.sender, vault, newCanPullFromIdle);\n    }\n\n    function setPenalty(address vault, uint64 newPenalty) external {\n        require(IVaultV2Factory(vaultV2Factory).isVaultV2(vault), NotVaultV2());\n        require(IVaultV2(vault).isAllocator(msg.sender), Unauthorized());\n        require(newPenalty <= WAD, PenaltyTooHigh());\n        vaultData[vault].penalty = newPenalty;\n        emit SetPenalty(msg.sender, vault, newPenalty);\n    }\n\n    /* PUBLIC FUNCTION */\n\n    function reallocate(\n        address vault,\n        address deallocateAdapter,\n        MarketParams calldata deallocateMarketParams,\n        address allocateAdapter,\n        MarketParams calldata allocateMarketParams,\n        uint128 assets,\n        uint64 penalty\n    ) external {\n        require(vaultData[vault].penalty == penalty, IncorrectPenalty());\n        uint256 penaltyAssets = MathLib.mulDivUp(assets, penalty, WAD);\n        if (penaltyAssets > 0) {\n            SafeERC20Lib.safeTransferFrom(allocateMarketParams.loanToken, msg.sender, vault, penaltyAssets);\n        }\n        require(isActiveAdapter[vault][deallocateAdapter], InactiveAdapter());\n        require(isActiveAdapter[vault][allocateAdapter], InactiveAdapter());\n        bytes32 deallocateId = vaultBlueId(deallocateAdapter, deallocateMarketParams);\n        require(canPullFromMarket[vault][deallocateId], CannotPullFromMarket());\n        bytes32 allocateId = vaultBlueId(allocateAdapter, allocateMarketParams);\n        require(absoluteCap[vault][allocateId] > 0, ZeroAbsoluteCap());\n\n        IVaultV2(vault).deallocate(deallocateAdapter, abi.encode(deallocateMarketParams), assets);\n        IVaultV2(vault).allocate(allocateAdapter, abi.encode(allocateMarketParams), assets);\n\n        require(IVaultV2(vault).allocation(allocateId) <= absoluteCap[vault][allocateId], AbsoluteCapExceeded());\n\n        emit Reallocate(\n            msg.sender, vault, deallocateAdapter, deallocateId, allocateAdapter, allocateId, assets, penaltyAssets\n        );\n    }\n\n    function allocateFromIdle(\n        address vault,\n        address adapter,\n        MarketParams calldata marketParams,\n        uint128 assets,\n        uint64 penalty\n    ) external {\n        require(vaultData[vault].penalty == penalty, IncorrectPenalty());\n        uint256 penaltyAssets = MathLib.mulDivUp(assets, penalty, WAD);\n        if (penaltyAssets > 0) SafeERC20Lib.safeTransferFrom(marketParams.loanToken, msg.sender, vault, penaltyAssets);\n        require(isActiveAdapter[vault][adapter], InactiveAdapter());\n        require(vaultData[vault].canPullFromIdle, CannotPullFromIdle());\n        bytes32 allocateId = vaultBlueId(adapter, marketParams);\n        require(absoluteCap[vault][allocateId] > 0, ZeroAbsoluteCap());\n\n        IVaultV2(vault).allocate(adapter, abi.encode(marketParams), assets);\n\n        require(IVaultV2(vault).allocation(allocateId) <= absoluteCap[vault][allocateId], AbsoluteCapExceeded());\n\n        emit AllocateFromIdle(msg.sender, vault, adapter, allocateId, assets, penaltyAssets);\n    }\n\n    /// @dev Returns the market's per-market vault id, exactly as keyed by the MorphoMarketV1AdapterV2.\n    function vaultBlueId(address adapter, MarketParams calldata marketParams) internal pure returns (bytes32) {\n        return keccak256(abi.encode(\"this/marketParams\", adapter, marketParams));\n    }\n}\n"},"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\n// Copyright (c) 2026 Morpho Association\npragma solidity >=0.8.0;\n\nimport {MarketParams} from \"../../../../lib/morpho-blue/src/interfaces/IMorpho.sol\";\n\nstruct VaultData {\n    bool canPullFromIdle;\n    uint64 penalty;\n}\n\n// forgefmt: disable-start\ninterface IBluePublicAllocator {\n\n    /* EVENTS */\n\n    event SetAbsoluteCap(address indexed sender, address indexed vault, address adapter, MarketParams marketParams, uint256 absoluteCap);\n    event SetCanPullFromMarket(address indexed sender, address indexed vault, address adapter, MarketParams marketParams, bool canPullFromMarket);\n    event SetCanPullFromIdle(address indexed sender, address indexed vault, bool canPullFromIdle);\n    event SetIsActiveAdapter(address indexed sender, address indexed vault, address indexed adapter, bool isActiveAdapter);\n    event SetPenalty(address indexed sender, address indexed vault, uint64 newPenalty);\n    event Reallocate(address sender, address indexed vault, address deallocateAdapter, bytes32 indexed deallocateId, address allocateAdapter, bytes32 indexed allocateId, uint128 assets, uint256 penaltyAssets);\n    event AllocateFromIdle(address indexed sender, address indexed vault, address adapter, bytes32 indexed allocateId, uint128 assets, uint256 penaltyAssets);\n\n    /* ERRORS */\n\n    error Unauthorized();\n    error AbsoluteCapExceeded();\n    error ZeroAbsoluteCap();\n    error CannotPullFromMarket();\n    error CannotPullFromIdle();\n    error InactiveAdapter();\n    error PenaltyTooHigh();\n    error IncorrectPenalty();\n    error NotVaultV2();\n\n    /* VIEW */\n\n    function vaultV2Factory() external view returns (address);\n    function absoluteCap(address vault, bytes32 id) external view returns (uint256);\n    function canPullFromMarket(address vault, bytes32 id) external view returns (bool);\n    function isActiveAdapter(address vault, address adapter) external view returns (bool);\n    function vaultData(address vault) external view returns (bool canPullFromIdle, uint64 penalty);\n\n    /* FUNCTIONS */\n\n    function multicall(bytes[] calldata data) external;\n    function setIsActiveAdapter(address vault, address adapter, bool newIsActiveAdapter) external;\n    function setAbsoluteCap(address vault, address adapter, MarketParams calldata marketParams, uint256 newAbsoluteCap) external;\n    function setCanPullFromMarket(address vault, address adapter, MarketParams calldata marketParams, bool newCanPullFromMarket) external;\n    function setCanPullFromIdle(address vault, bool newCanPullFromIdle) external;\n    function setPenalty(address vault, uint64 newPenalty) external;\n    function reallocate(address vault, address deallocateAdapter, MarketParams calldata deallocateMarketParams, address allocateAdapter, MarketParams calldata allocateMarketParams, uint128 assets, uint64 penalty) external;\n    function allocateFromIdle(address vault, address adapter, MarketParams calldata marketParams, uint128 assets, uint64 penalty) external;\n}\n// forgefmt: disable-end\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":100000,"enabled":true},"evmVersion":"cancun","remappings":["solmate/=lib/bundler3/lib/permit2/lib/solmate/","@openzeppelin/contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/contracts/","bundler3/=lib/bundler3/","bundles/=lib/bundles/","ds-test/=lib/metamorpho-1.1/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/metamorpho-1.1/lib/erc4626-tests/","forge-gas-snapshot/=lib/bundler3/lib/permit2/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/morpho-blue/lib/halmos-cheatcodes/src/","metamorpho-1.1/=lib/metamorpho-1.1/","metamorpho-v1.1/=lib/vault-v2/lib/metamorpho-v1.1/","metamorpho/=lib/vault-v2/lib/metamorpho/","midnight/=lib/midnight/","morpho-blue-irm/=lib/morpho-blue-irm/src/","morpho-blue-oracles/=lib/morpho-blue-oracles/src/","morpho-blue/=lib/morpho-blue/","murky/=lib/universal-rewards-distributor/lib/murky/src/","openzeppelin-contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/","openzeppelin/=lib/universal-rewards-distributor/lib/openzeppelin-contracts/contracts/","permit2/=lib/bundler3/lib/permit2/","pre-liquidation/=lib/pre-liquidation/src/","public-allocator/=lib/public-allocator/src/","safe-smart-account/=lib/safe-smart-account/","universal-rewards-distributor/=lib/universal-rewards-distributor/src/","vault-v2-adapter-registries/=lib/vault-v2-adapter-registries/src/","vault-v2/=lib/vault-v2/"]}},"stdJsonOutput":{"sources":{"lib/vault-v2/src/interfaces/IERC20.sol":{"id":1},"lib/vault-v2/src/libraries/MathLib.sol":{"id":8},"lib/vault-v2/src/interfaces/IERC2612.sol":{"id":2},"lib/vault-v2/src/interfaces/IERC4626.sol":{"id":3},"lib/vault-v2/src/interfaces/IVaultV2.sol":{"id":4},"lib/vault-v2/src/libraries/ErrorsLib.sol":{"id":7},"lib/vault-v2/src/libraries/ConstantsLib.sol":{"id":6},"lib/vault-v2/src/libraries/SafeERC20Lib.sol":{"id":9},"lib/vault-v2/src/interfaces/IVaultV2Factory.sol":{"id":5},"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol":{"id":0},"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"id":10},"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol":{"id":11}},"contracts":{"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol":{"BluePublicAllocator":{"abi":[{"type":"constructor","inputs":[{"name":"_vaultV2Factory","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AbsoluteCapExceeded","type":"error","inputs":[]},{"name":"CannotPullFromIdle","type":"error","inputs":[]},{"name":"CannotPullFromMarket","type":"error","inputs":[]},{"name":"InactiveAdapter","type":"error","inputs":[]},{"name":"IncorrectPenalty","type":"error","inputs":[]},{"name":"NoCode","type":"error","inputs":[]},{"name":"NotVaultV2","type":"error","inputs":[]},{"name":"PenaltyTooHigh","type":"error","inputs":[]},{"name":"TransferFromReturnedFalse","type":"error","inputs":[]},{"name":"TransferFromReverted","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"ZeroAbsoluteCap","type":"error","inputs":[]},{"name":"AllocateFromIdle","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"allocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"assets","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"penaltyAssets","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Reallocate","type":"event","inputs":[{"name":"sender","type":"address","indexed":false,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"deallocateAdapter","type":"address","indexed":false,"internalType":"address"},{"name":"deallocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"allocateAdapter","type":"address","indexed":false,"internalType":"address"},{"name":"allocateId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"assets","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"penaltyAssets","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SetAbsoluteCap","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"marketParams","type":"tuple","indexed":false,"components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"absoluteCap","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SetCanPullFromIdle","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"canPullFromIdle","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetCanPullFromMarket","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":false,"internalType":"address"},{"name":"marketParams","type":"tuple","indexed":false,"components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"canPullFromMarket","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsActiveAdapter","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"adapter","type":"address","indexed":true,"internalType":"address"},{"name":"isActiveAdapter","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetPenalty","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"newPenalty","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"absoluteCap","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allocateFromIdle","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"assets","type":"uint128","internalType":"uint128"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"canPullFromMarket","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isActiveAdapter","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"reallocate","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"deallocateAdapter","type":"address","internalType":"address"},{"name":"deallocateMarketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"allocateAdapter","type":"address","internalType":"address"},{"name":"allocateMarketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"assets","type":"uint128","internalType":"uint128"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAbsoluteCap","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"newAbsoluteCap","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCanPullFromIdle","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newCanPullFromIdle","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCanPullFromMarket","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"marketParams","type":"tuple","components":[{"name":"loanToken","type":"address","internalType":"address"},{"name":"collateralToken","type":"address","internalType":"address"},{"name":"oracle","type":"address","internalType":"address"},{"name":"irm","type":"address","internalType":"address"},{"name":"lltv","type":"uint256","internalType":"uint256"}],"internalType":"struct MarketParams"},{"name":"newCanPullFromMarket","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsActiveAdapter","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"adapter","type":"address","internalType":"address"},{"name":"newIsActiveAdapter","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPenalty","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newPenalty","type":"uint64","internalType":"uint64"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vaultData","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"canPullFromIdle","type":"bool","internalType":"bool"},{"name":"penalty","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"vaultV2Factory","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_vaultV2Factory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AbsoluteCapExceeded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CannotPullFromIdle\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CannotPullFromMarket\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InactiveAdapter\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IncorrectPenalty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoCode\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotVaultV2\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PenaltyTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFromReturnedFalse\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFromReverted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAbsoluteCap\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"allocateId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"assets\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"penaltyAssets\",\"type\":\"uint256\"}],\"name\":\"AllocateFromIdle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"deallocateAdapter\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"deallocateId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"allocateAdapter\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"allocateId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"assets\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"penaltyAssets\",\"type\":\"uint256\"}],\"name\":\"Reallocate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct MarketParams\",\"name\":\"marketParams\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"absoluteCap\",\"type\":\"uint256\"}],\"name\":\"SetAbsoluteCap\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"canPullFromIdle\",\"type\":\"bool\"}],\"name\":\"SetCanPullFromIdle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct MarketParams\",\"name\":\"marketParams\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"canPullFromMarket\",\"type\":\"bool\"}],\"name\":\"SetCanPullFromMarket\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isActiveAdapter\",\"type\":\"bool\"}],\"name\":\"SetIsActiveAdapter\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newPenalty\",\"type\":\"uint64\"}],\"name\":\"SetPenalty\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"}],\"name\":\"absoluteCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"internalType\":\"struct MarketParams\",\"name\":\"marketParams\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"assets\",\"type\":\"uint128\"},{\"internalType\":\"uint64\",\"name\":\"penalty\",\"type\":\"uint64\"}],\"name\":\"allocateFromIdle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"}],\"name\":\"canPullFromMarket\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"}],\"name\":\"isActiveAdapter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"multicall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"deallocateAdapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"internalType\":\"struct MarketParams\",\"name\":\"deallocateMarketParams\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"allocateAdapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"internalType\":\"struct MarketParams\",\"name\":\"allocateMarketParams\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"assets\",\"type\":\"uint128\"},{\"internalType\":\"uint64\",\"name\":\"penalty\",\"type\":\"uint64\"}],\"name\":\"reallocate\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"internalType\":\"struct MarketParams\",\"name\":\"marketParams\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"newAbsoluteCap\",\"type\":\"uint256\"}],\"name\":\"setAbsoluteCap\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"newCanPullFromIdle\",\"type\":\"bool\"}],\"name\":\"setCanPullFromIdle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"loanToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oracle\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"irm\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"lltv\",\"type\":\"uint256\"}],\"internalType\":\"struct MarketParams\",\"name\":\"marketParams\",\"type\":\"tuple\"},{\"internalType\":\"bool\",\"name\":\"newCanPullFromMarket\",\"type\":\"bool\"}],\"name\":\"setCanPullFromMarket\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"adapter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"newIsActiveAdapter\",\"type\":\"bool\"}],\"name\":\"setIsActiveAdapter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newPenalty\",\"type\":\"uint64\"}],\"name\":\"setPenalty\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"vaultData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"canPullFromIdle\",\"type\":\"bool\"},{\"internalType\":\"uint64\",\"name\":\"penalty\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vaultV2Factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"To be usable, the BluePublicAllocator must be set as an allocator of the vault.Meant to be used with VaultV2 vaults only.Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system could break.The vault's allocators can manage the public allocators' settings.Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which increases the rate like forceDeallocate penalties).The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between signing and execution.The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.The public allocator's caps are not checked on allocations from the vault (either by allocators or through deposits).The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but it requires capital).reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.Reallocations (notably through this contract) can reduce the vault's \\\"direct\\\" liquidity by pulling assets from idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.\",\"kind\":\"dev\",\"methods\":{\"multicall(bytes[])\":{\"details\":\"Useful for EOAs to batch allocator calls.Does not return anything, because accounts who would use the return data would be contracts, which can do the multicall themselves.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol\":\"BluePublicAllocator\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":100000},\"remappings\":[\":@openzeppelin/contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/contracts/\",\":bundler3/=lib/bundler3/\",\":bundles/=lib/bundles/\",\":ds-test/=lib/metamorpho-1.1/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/metamorpho-1.1/lib/erc4626-tests/\",\":forge-gas-snapshot/=lib/bundler3/lib/permit2/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/morpho-blue/lib/halmos-cheatcodes/src/\",\":metamorpho-1.1/=lib/metamorpho-1.1/\",\":metamorpho-v1.1/=lib/vault-v2/lib/metamorpho-v1.1/\",\":metamorpho/=lib/vault-v2/lib/metamorpho/\",\":midnight/=lib/midnight/\",\":morpho-blue-irm/=lib/morpho-blue-irm/src/\",\":morpho-blue-oracles/=lib/morpho-blue-oracles/src/\",\":morpho-blue/=lib/morpho-blue/\",\":murky/=lib/universal-rewards-distributor/lib/murky/src/\",\":openzeppelin-contracts/=lib/metamorpho-1.1/lib/openzeppelin-contracts/\",\":openzeppelin/=lib/universal-rewards-distributor/lib/openzeppelin-contracts/contracts/\",\":permit2/=lib/bundler3/lib/permit2/\",\":pre-liquidation/=lib/pre-liquidation/src/\",\":public-allocator/=lib/public-allocator/src/\",\":safe-smart-account/=lib/safe-smart-account/\",\":solmate/=lib/bundler3/lib/permit2/lib/solmate/\",\":universal-rewards-distributor/=lib/universal-rewards-distributor/src/\",\":vault-v2-adapter-registries/=lib/vault-v2-adapter-registries/src/\",\":vault-v2/=lib/vault-v2/\"],\"viaIR\":true},\"sources\":{\"lib/vault-v2/lib/morpho-blue/src/interfaces/IMorpho.sol\":{\"keccak256\":\"0x5c50a9c93ea7d6c21472f68be7e32404d0cc5637b8df14994ddf9c87ef507afa\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://a63a40b090f74cbf96c7a67872110085d494bdeec8818372d53fd8cae0fec893\",\"dweb:/ipfs/QmYR9n9tYHY1DrpGHMSNDggbsYBbMPs44Cbs7Rwh8vK2Qn\"]},\"lib/vault-v2/src/interfaces/IERC20.sol\":{\"keccak256\":\"0x4e66403784cf08fa5b5dc072b0ddb5a168dd69e8c3cdb912eed37e7da43f32a7\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://b67ef4141949be81dc2176a28334430687013f142ccc22f62b569a0cb90abd14\",\"dweb:/ipfs/QmNsfyx5cGaDjWoMJiPdLnNwBvCk1PqBcKYqL935aUDemu\"]},\"lib/vault-v2/src/interfaces/IERC2612.sol\":{\"keccak256\":\"0x8a6a5882a5ade43ae94e7406251df9911a782f34ad723df857c8a2d8764a77fe\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://12767619d08b112738bed4f6d6df29771730ca65f52c64edb9854a0c19af1c82\",\"dweb:/ipfs/QmeqUTxqRfRz6UQkbqJaRMAmL9D4eSPDeARYhSKxR9gZNt\"]},\"lib/vault-v2/src/interfaces/IERC4626.sol\":{\"keccak256\":\"0x49085f03fc0d7bd727b2c3cc1ae3e5b975f8a863011ec8fda293b613c611a7c3\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://38c86fc0c3d21190aec87f79009d24849170b66f411209e106cc279e8164c425\",\"dweb:/ipfs/QmRNQMWnoebdj3wq77NxSsYAJpDTjdFFKi3ASXHe74yvYq\"]},\"lib/vault-v2/src/interfaces/IVaultV2.sol\":{\"keccak256\":\"0xd2e10276f2e354162ee695eb0700f2567b4e0e635bc03b5a669aa4ac78b15633\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://12c80ecbac96d303dd09714c411751a4241278a0c758af3906d19a50203ee602\",\"dweb:/ipfs/QmP8BEViY32ndKGSameP83xcJhUw83NBVjrZRVbMqWDi48\"]},\"lib/vault-v2/src/interfaces/IVaultV2Factory.sol\":{\"keccak256\":\"0x1b5dbe5ef07cf9d3cccf8ad823e47f50abbc5a605b8183d81c90cd052dec438e\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://8cb7483a9d84185ca8eeccaaf30375510238bd41517777b164568c23542f5297\",\"dweb:/ipfs/QmYVyGTKSLqjpnb7qR25fdFf6s1uLszg529dcciYjmaK84\"]},\"lib/vault-v2/src/libraries/ConstantsLib.sol\":{\"keccak256\":\"0xbe50152193f26320f4ced8deb26e8cede70d08164ef33a33599c9edf2b3c8898\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://d915b6a9060f16899ccbe5713211cb15930ede56d8bdea835485826239b99c6d\",\"dweb:/ipfs/Qma1522ndLixZh4jYMcqgpXyZqiJWk2aD8NNUViy4gJ2p7\"]},\"lib/vault-v2/src/libraries/ErrorsLib.sol\":{\"keccak256\":\"0xd339b9f13a8adaaa8313ec5f1e0450a60c1f23b2d45ac4efbd4d93898efbff3f\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://0dd317e65dac6d40396cd51984bb53880ce9e1ea4a38d69ca19d9cd9f49d995c\",\"dweb:/ipfs/QmdpD5piXTmPgAfcux6EeYuMP81zJf6x5c5rJpfNy5HyZK\"]},\"lib/vault-v2/src/libraries/MathLib.sol\":{\"keccak256\":\"0x67d6eaa5d36502665f6527e9468af49be20b56aa1a4abab8ca49f50add0d2436\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://5b1b5c98d93c681b91385c248a2287def1c0809ffcc807d44417d826ccdd2336\",\"dweb:/ipfs/QmVA2YbLk5nKw8G7LH7mvxydpQUqaxrfffadvF8b7ZH7Gu\"]},\"lib/vault-v2/src/libraries/SafeERC20Lib.sol\":{\"keccak256\":\"0xfa2011ae673cdf3f5f7e2c3c2596e30ac6fb1b8ad006d8d88c128e1165245d9c\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://f6f44b235cc3990462dd4ed9bb13b02c03bd50fe352cef7d2c926b3e0f7180f6\",\"dweb:/ipfs/QmWkJmmoEWVgsjULi1eYUAgfkVWXiMzJS99AT1JaoVFpm2\"]},\"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol\":{\"keccak256\":\"0x2bbfadb1914ce4735f54752ce2215037121a5765f3495caa72d1fc03d910b5e6\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://5e91ba581d13ee4f57cff4ebf85b37170ae796952775e8ecbec6d2b1829e157c\",\"dweb:/ipfs/QmZmNHG9M5bzD1SkMuYnrX23BFoCLaQXwztbFLjvXZqjAn\"]},\"lib/vault-v2/src/periphery/blue-public-allocator/interfaces/IBluePublicAllocator.sol\":{\"keccak256\":\"0x91308d2623789a6d786a4729dd91471981d8a3ef742fd0f94ce243daa410caaa\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://02bee0e11f9f3771673fa3f5a25ca4ae495daf1d82c3775cd59bd0c66a92c8f7\",\"dweb:/ipfs/QmVSSEhsKoprUkMn9GV4EMP5fAYa4EUc6NJZ9mgZbBCQox\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","details":"To be usable, the BluePublicAllocator must be set as an allocator of the vault.Meant to be used with VaultV2 vaults only.Active adapters must be MorphoMarketV1AdapterV2 adapters, otherwise the public allocator's absolute cap system could break.The vault's allocators can manage the public allocators' settings.Each reallocate and allocateFromIdle call costs a proportional penalty, paid by the caller in the vault's asset. The penalty is set per vault by the allocators and is transferred directly to the vault (a donation, which increases the rate like forceDeallocate penalties).The penalty parameter of reallocate and allocateFromIdle protects callers against penalty changes between signing and execution.The vault's caps are still enforced on the allocation, so allocation calls reverts if it would exceed them.The public allocator's caps are not checked on allocations from the vault (either by allocators or through deposits).The BluePublicAllocator opens the door for anybody to manipulate relative caps through short-term deposits (but it requires capital).reallocate and allocateFromIdle can be made to revert by anyone frontrunning them (not only allocators): an allocate reverts if the vault cap is filled first, a deallocate reverts if shares stop covering assets.Reallocations (notably through this contract) can reduce the vault's \"direct\" liquidity by pulling assets from idle and from the liquidity market. It can also block deposit by reaching the liquidity market's caps.","methods":{"multicall(bytes[])":{"details":"Useful for EOAs to batch allocator calls.Does not return anything, because accounts who would use the return data would be contracts, which can do the multicall themselves."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint64":{"label":"uint64","encoding":"inplace","numberOfBytes":"8"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_bool)":{"key":"t_bytes32","label":"mapping(bytes32 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_uint256)":{"key":"t_bytes32","label":"mapping(bytes32 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(VaultData)2225_storage":{"label":"struct VaultData","members":[{"slot":"0","type":"t_bool","astId":2222,"label":"canPullFromIdle","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"0","type":"t_uint64","astId":2224,"label":"penalty","offset":1,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes32,t_bool))":{"key":"t_address","label":"mapping(address => mapping(bytes32 => bool))","value":"t_mapping(t_bytes32,t_bool)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes32,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(bytes32 => uint256))","value":"t_mapping(t_bytes32,t_uint256)","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(VaultData)2225_storage)":{"key":"t_address","label":"mapping(address => struct VaultData)","value":"t_struct(VaultData)2225_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_mapping(t_bytes32,t_uint256))","astId":1572,"label":"absoluteCap","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_bytes32,t_bool))","astId":1578,"label":"canPullFromMarket","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":1584,"label":"isActiveAdapter","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"},{"slot":"3","type":"t_mapping(t_address,t_struct(VaultData)2225_storage)","astId":1589,"label":"vaultData","offset":0,"contract":"lib/vault-v2/src/periphery/blue-public-allocator/BluePublicAllocator.sol:BluePublicAllocator"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"2209:6306:10:-:0;;;;;;;;;;;;;-1:-1:-1;;2209:6306:10;;;;-1:-1:-1;;;;;2209:6306:10;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2209:6306:10;;;;;;2736:32;;2209:6306;;;;;;;;2736:32;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10","linkReferences":{}},"deployedBytecode":{"object":"6080806040526004361015610012575f80fd5b5f905f3560e01c90816308f804d81461188e575080635e0deb541461165157806366faa839146115c057806369f1e26b1461154c57806377b0aab1146113385780637953b569146112ca5780638aeed1d11461107d5780638fdaa1a714610a9f5780639a8a67951461086a5780639a8b594414610628578063ac9650d814610511578063d72ff79a146104975763df31d688146100ad575f80fd5b34610494576101207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc360112610494576100e56118f7565b6100ed61191a565b9060a07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbc3601126103b75760e435916fffffffffffffffffffffffffffffffff83169182840361049257610104359267ffffffffffffffff84168094036103a85773ffffffffffffffffffffffffffffffffffffffff82169384875260036020528067ffffffffffffffff604089205460081c160361046a576101909082611c7d565b9182610433575b5083865260026020526040862073ffffffffffffffffffffffffffffffffffffffff84165f5260205260ff60405f2054161561040b57838652600360205260ff604087205416156103e3576101eb83611c02565b9484875286602052604087208688526020526040872054156103bb578690604051610218602082016119e4565b60a0815261022760c08261195e565b863b156103b75761026991839160405193849283927f5c9ce04d0000000000000000000000000000000000000000000000000000000084528a60048501611b24565b0381838a5af180156103ac57610393575b50506040517fc69507dd000000000000000000000000000000000000000000000000000000008152856004820152602081602481885afa908115610388578791610352575b50848752866020526040872086885260205260408720541061032a5773ffffffffffffffffffffffffffffffffffffffff60405193168352602083015260408201527f141dc311848af2dd1094d09b33fbf388787803a6f8d59038c066adf920300cff60603392a480f35b6004867f4616e4af000000000000000000000000000000000000000000000000000000008152fd5b90506020813d602011610380575b8161036d6020938361195e565b8101031261037c57515f6102bf565b5f80fd5b3d9150610360565b6040513d89823e3d90fd5b8161039d9161195e565b6103a857855f61027a565b8580fd5b6040513d84823e3d90fd5b8280fd5b6004877fbb1a23b9000000000000000000000000000000000000000000000000000000008152fd5b6004867f79211beb000000000000000000000000000000000000000000000000000000008152fd5b6004867f8d3a1180000000000000000000000000000000000000000000000000000000008152fd5b60443573ffffffffffffffffffffffffffffffffffffffff81168103610466576104609184913390611cda565b5f610197565b8780fd5b6004877f7267792a000000000000000000000000000000000000000000000000000000008152fd5b845b80fd5b50346104945760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc360112610494576040809173ffffffffffffffffffffffffffffffffffffffff6104e86118f7565b1681526003602052205467ffffffffffffffff82519160ff81161515835260081c166020820152f35b50346104945760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc360112610494576004359067ffffffffffffffff8211610494573660238301121561049457816004013567ffffffffffffffff8111610624573660248260051b85010111610624579181907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbd81360301915b848110156106205760248160051b830101358381121561049257820160248101359067ffffffffffffffff82116103a85760440181360381136103a857818692918392604051928392833781018381520390305af4610609611ba5565b901561061857506001016105ac565b805190602001fd5b8380f35b5080fd5b50346104945760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc360112610494576106606118f7565b602435801515908181036108665773ffffffffffffffffffffffffffffffffffffffff604051937f5edec50d000000000000000000000000000000000000000000000000000000008552169283600482015260208160248173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000165afa908115610814578591610847575b501561081f576040517f4dedf20e000000000000000000000000000000000000000000000000000000008152336004820152602081602481875afa9081156108145785916107e5575b50156107bd5761078e908385526003602052604085209060ff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0083541691151516179055565b6040519081527f69f0f5f31610c9bb0b1c7325d8098a0c7d6093e0ea7fbf9920eb46f349bfe07c60203392a380f35b6004847f82b42900000000000000000000000000000000000000000000000000000000008152fd5b610807915060203d60201161080d575b6107ff818361195e565b8101906119cc565b5f610748565b503d6107f5565b6040513d87823e3d90fd5b6004847f1a9141e7000000000000000000000000000000000000000000000000000000008152fd5b610860915060203d60201161080d576107ff818361195e565b5f6106ff565b8380fd5b5034610494576101007ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc360112610494576108a36118f7565b6108ab61191a565b60a07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbc3601126103b75760e43573ffffffffffffffffffffffffffffffffffffffff604051937f5edec50d000000000000000000000000000000000000000000000000000000008552169283600482015260208160248173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000165afa908115610814578591610a80575b501561081f5761097882611c02565b6040517f4dedf20e000000000000000000000000000000000000000000000000000000008152336004820152602081602481885afa908115610a75578691610a56575b5015610a2e57838552846020526040852090855260205280604085205573ffffffffffffffffffffffffffffffffffffffff60405192168252610a00602083016119e4565b60c08201527f1a77abe8031078d6f3fc79dbd2a5cfa48ae8dbb495fcf0b3124cf009bb6d91c360e03392a380f35b6004857f82b42900000000000000000000000000000000000000000000000000000000008152fd5b610a6f915060203d60201161080d576107ff818361195e565b5f6109bb565b6040513d88823e3d90fd5b610a99915060203d60201161080d576107ff818361195e565b5f610969565b503461037c576101e07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c57610ad86118f7565b610ae061191a565b9060a07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbc36011261037c5760e4359173ffffffffffffffffffffffffffffffffffffffff83169081840361037c5760a07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffefc36011261037c576101a435926fffffffffffffffffffffffffffffffff841680850361037c576101c4359367ffffffffffffffff851680950361037c5773ffffffffffffffffffffffffffffffffffffffff831694855f5260036020528067ffffffffffffffff60405f205460081c160361105557610bd09083611c7d565b9283611021575b50845f52600260205260405f2073ffffffffffffffffffffffffffffffffffffffff85165f5260205260ff60405f20541615610ff957845f52600260205260405f20815f5260205260ff60405f20541615610ff957610c3584611c02565b95855f52600160205260405f20875f5260205260ff60405f20541615610fd157604051602081019060e0825260116101008201527f746869732f6d61726b6574506172616d73000000000000000000000000000000610120820152836040820152610ca560608201610104611a83565b6101208152610cb66101408261195e565b51902097865f525f60205260405f20895f5260205260405f205415610fa957604051610ce4602082016119e4565b60a08152610cf360c08261195e565b873b1561037c575f83610d359260405193849283927f4b219d160000000000000000000000000000000000000000000000000000000084528c60048501611b24565b0381838c5af18015610f9e57610f87575b509089916040516101043573ffffffffffffffffffffffffffffffffffffffff81168091036104925760208201526101243573ffffffffffffffffffffffffffffffffffffffff81168091036104925760408201526101443573ffffffffffffffffffffffffffffffffffffffff81168091036104925760608201526101643573ffffffffffffffffffffffffffffffffffffffff81168091036104925760808201526101843560a082015260a08152610e0160c08261195e565b883b15610866578391610e4160405194859384937f5c9ce04d00000000000000000000000000000000000000000000000000000000855260048501611b24565b0381838b5af180156103ac57610f72575b50506040517fc69507dd000000000000000000000000000000000000000000000000000000008152876004820152602081602481895afa908115610f67578991610f35575b508589528860205260408920888a52602052604089205410610f0d576040805133815273ffffffffffffffffffffffffffffffffffffffff9095166020860152840152606083015260808201527f813a174ef9435466c79f45c3051c14bab72e0c8f5d0f265105e33c3d6d5ddcf79060a090a480f35b6004887f4616e4af000000000000000000000000000000000000000000000000000000008152fd5b90506020813d602011610f5f575b81610f506020938361195e565b8101031261037c57515f610e97565b3d9150610f43565b6040513d8b823e3d90fd5b81610f7c9161195e565b61046657875f610e52565b610f9591929a505f9061195e565b5f98905f610d46565b6040513d5f823e3d90fd5b7fbb1a23b9000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fff07b0d3000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f8d3a1180000000000000000000000000000000000000000000000000000000005f5260045ffd5b6101043573ffffffffffffffffffffffffffffffffffffffff8116810361037c5761104f9185913390611cda565b5f610bd7565b7f7267792a000000000000000000000000000000000000000000000000000000005f5260045ffd5b3461037c5760607ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c576110b46118f7565b6110bc61191a565b906044358015159283820361037c5773ffffffffffffffffffffffffffffffffffffffff604051937f5edec50d000000000000000000000000000000000000000000000000000000008552169283600482015260208160248173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000165afa908115610f9e575f916112ab575b5015611283576040517f4dedf20e000000000000000000000000000000000000000000000000000000008152336004820152602081602481875afa908115610f9e575f91611264575b501561123c5761120c73ffffffffffffffffffffffffffffffffffffffff92845f52600260205260405f208484165f5260205260405f209060ff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0083541691151516179055565b60405193845216917fcb0caee6dfd90d41657a1c2834c4139aff2ad434ddb51eecd2ea298d3580953e60203392a4005b7f82b42900000000000000000000000000000000000000000000000000000000005f5260045ffd5b61127d915060203d60201161080d576107ff818361195e565b856111a5565b7f1a9141e7000000000000000000000000000000000000000000000000000000005f5260045ffd5b6112c4915060203d60201161080d576107ff818361195e565b8561115c565b3461037c575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c57602060405173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152f35b3461037c5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c5761136f6118f7565b60243567ffffffffffffffff81169081810361037c5773ffffffffffffffffffffffffffffffffffffffff604051937f5edec50d000000000000000000000000000000000000000000000000000000008552169283600482015260208160248173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000165afa908115610f9e575f9161152d575b5015611283576040517f4dedf20e000000000000000000000000000000000000000000000000000000008152336004820152602081602481875afa908115610f9e575f9161150e575b501561123c57670de0b6b3a764000082116114e657825f52600360205260405f20907fffffffffffffffffffffffffffffffffffffffffffffff0000000000000000ff68ffffffffffffffff0083549260081b1691161790556040519081527f87592866e19f1c7e3aba38aff71910bf6cde4d2aea6dd48bacc5d21b59f68b8c60203392a3005b7f516e7f38000000000000000000000000000000000000000000000000000000005f5260045ffd5b611527915060203d60201161080d576107ff818361195e565b8461145f565b611546915060203d60201161080d576107ff818361195e565b84611416565b3461037c5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c5773ffffffffffffffffffffffffffffffffffffffff6115986118f7565b165f52600160205260405f206024355f52602052602060ff60405f2054166040519015158152f35b3461037c5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c576115f76118f7565b73ffffffffffffffffffffffffffffffffffffffff61161461191a565b91165f52600260205273ffffffffffffffffffffffffffffffffffffffff60405f2091165f52602052602060ff60405f2054166040519015158152f35b3461037c576101007ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c576116896118f7565b61169161191a565b60a07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbc36011261037c5760e4358015159081810361037c5773ffffffffffffffffffffffffffffffffffffffff604051947f5edec50d000000000000000000000000000000000000000000000000000000008652169384600482015260208160248173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000165afa908115610f9e575f9161186f575b5015611283576040517f4dedf20e000000000000000000000000000000000000000000000000000000008152336004820152602081602481885afa908115610f9e575f91611850575b501561123c576117fb90845f52600160205260405f206117c285611c02565b5f5260205260405f209060ff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0083541691151516179055565b73ffffffffffffffffffffffffffffffffffffffff60405192168252611823602083016119e4565b60c08201527facfd800238adbc79248c080c459b374b06feb519a69654529b318273686e1ab660e03392a3005b611869915060203d60201161080d576107ff818361195e565b856117a3565b611888915060203d60201161080d576107ff818361195e565b8561175a565b3461037c5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261037c5760209073ffffffffffffffffffffffffffffffffffffffff6118dd6118f7565b165f525f825260405f206024355f52825260405f20548152f35b6004359073ffffffffffffffffffffffffffffffffffffffff8216820361037c57565b6024359073ffffffffffffffffffffffffffffffffffffffff8216820361037c57565b359073ffffffffffffffffffffffffffffffffffffffff8216820361037c57565b90601f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0910116810190811067ffffffffffffffff82111761199f57604052565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b9081602091031261037c5751801515810361037c5790565b60443573ffffffffffffffffffffffffffffffffffffffff811680910361037c57815260643573ffffffffffffffffffffffffffffffffffffffff811680910361037c57602082015260843573ffffffffffffffffffffffffffffffffffffffff811680910361037c57604082015260a43573ffffffffffffffffffffffffffffffffffffffff811680910361037c576060820152608060c435910152565b6080809173ffffffffffffffffffffffffffffffffffffffff611aa58261193d565b16845273ffffffffffffffffffffffffffffffffffffffff611ac96020830161193d565b16602085015273ffffffffffffffffffffffffffffffffffffffff611af06040830161193d565b16604085015273ffffffffffffffffffffffffffffffffffffffff611b176060830161193d565b1660608501520135910152565b9160807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f60206fffffffffffffffffffffffffffffffff9473ffffffffffffffffffffffffffffffffffffffff6040979a999a16885260608289015280519182918260608b0152018589015e5f84828901015201168401019416910152565b3d15611bfd573d9067ffffffffffffffff821161199f5760405191611bf260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116018461195e565b82523d5f602084013e565b606090565b60405173ffffffffffffffffffffffffffffffffffffffff602082019260e0845260116101008401527f746869732f6d61726b6574506172616d73000000000000000000000000000000610120840152166040820152611c66606082016044611a83565b6101208152611c776101408261195e565b51902090565b818102918183041490151715611cad57670de0b6b3a763ffff8101809111611cad57670de0b6b3a7640000900490565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b90813b15611ddc575f809493819473ffffffffffffffffffffffffffffffffffffffff604051928160208501967f23b872dd000000000000000000000000000000000000000000000000000000008852166024850152166044830152606482015260648152611d4a60848261195e565b51925af1611d56611ba5565b9015611db4578051908115918215611d9a575b505015611d7257565b7f1eded19c000000000000000000000000000000000000000000000000000000005f5260045ffd5b611dad92506020809183010191016119cc565b5f80611d69565b7fe65b7a77000000000000000000000000000000000000000000000000000000005f5260045ffd5b7ff046a714000000000000000000000000000000000000000000000000000000005f5260045ffdfea164736f6c634300081c000a","sourceMap":"2209:6306:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7386:9;2209:6306;;;;;;;;;;;7386:35;2209:6306;;7476:38;;;;:::i;:::-;7528:17;;7524:110;;2209:6306;;;;;7652:15;2209:6306;;;;;;;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;7386:9;2209:6306;;;;;;;;;;;7807:34;;;:::i;:::-;2209:6306;;;;;;;;;;;;;;;;;;;7859:34;2209:6306;;;;;;;;7958:24;;2209:6306;:::i;:::-;;7958:24;;;;;;:::i;:::-;7924:67;;;;;;2209:6306;;;;;7924:67;;;;;2209:6306;7924:67;;;2209:6306;7924:67;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;8010:38;;;2209:6306;8010:38;;2209:6306;;8010:38;2209:6306;8010:38;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;;;;;;;;;8122:79;2209:6306;8139:10;8122:79;;2209:6306;;;;;;;;;8010:38;;;2209:6306;8010:38;;2209:6306;8010:38;;;;;;2209:6306;8010:38;;;:::i;:::-;;;2209:6306;;;;;8010:38;;;2209:6306;-1:-1:-1;2209:6306:10;;8010:38;;;-1:-1:-1;8010:38:10;;;2209:6306;;;;;;;;;7924:67;;;;;:::i;:::-;2209:6306;;7924:67;;;;2209:6306;;;;7924:67;2209:6306;;;;;;;;;7924:67;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;7524:110;2209:6306;;;;;;;;;7620:13;;2209:6306;;7601:10;;7620:13;:::i;:::-;7524:110;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2607:52;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3076:13;;2209:6306;;;;;;3071:314;3108:3;3091:15;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3169:35;3177:4;;3169:35;;;;:::i;:::-;3222:8;;3218:157;;3108:3;2209:6306;;3076:13;;3218:157;3250:111;;;2209:6306;3250:111;;3091:15;;2209:6306;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;4959:48;2209:6306;4959:48;;2209:6306;4959:48;;2209:6306;4959:48;;2209:6306;;4975:14;2209:6306;4975:14;2209:6306;4975:14;2209:6306;4959:48;;;;;;;;;;;2209:6306;;;;;;;;5040:39;;5068:10;2209:6306;5040:39;;2209:6306;;5040:39;2209:6306;5040:39;;;;;;;;;;;;;2209:6306;;;;;5106:53;2209:6306;;;;5106:9;2209:6306;;;;;;;;;;;;;;;;;;;5106:53;2209:6306;;;;;5174:57;2209:6306;5068:10;5174:57;;2209:6306;;;;;;;;;5040:39;;;;2209:6306;5040:39;2209:6306;5040:39;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;4959:48;;;;2209:6306;4959:48;2209:6306;4959:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;3989:48;2209:6306;3989:48;;2209:6306;3989:48;;2209:6306;3989:48;;2209:6306;;4005:14;2209:6306;4005:14;2209:6306;4005:14;2209:6306;3989:48;;;;;;;;;;;2209:6306;;;;;4075:34;;;:::i;:::-;2209:6306;;;4127:39;;4155:10;2209:6306;4127:39;;2209:6306;;4127:39;2209:6306;4127:39;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;4247:72;2209:6306;4155:10;4247:72;;2209:6306;;;;;;;;;4127:39;;;;2209:6306;4127:39;2209:6306;4127:39;;;;;;;:::i;:::-;;;;;2209:6306;;;;;;;;;3989:48;;;;2209:6306;3989:48;2209:6306;3989:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5957:9;2209:6306;;;;;;;;;;;5957:35;2209:6306;;6047:38;;;;:::i;:::-;6099:17;;6095:143;;2209:6306;;;;;6255:15;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;6255:15;2209:6306;;;;;;;;;;;;;;;;;;;6426:54;;;:::i;:::-;2209:6306;;;;6498:17;2209:6306;;;;;;;;;;;;;;;;;;;;;;8451:54;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8451:54;;;;;;:::i;:::-;2209:6306;8441:65;;2209:6306;;;;;;;;;;;;;;;;;;;6660:34;2209:6306;;;;;;6771:34;;2209:6306;:::i;:::-;;6771:34;;;;;;:::i;:::-;6725:89;;;;;2209:6306;;6725:89;2209:6306;;;6725:89;;;;;2209:6306;6725:89;;;2209:6306;6725:89;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;6866:32;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6866:32;;;6771:34;6866:32;;:::i;:::-;6824:83;;;;;2209:6306;;6824:83;2209:6306;;6824:83;;;;;2209:6306;6824:83;;2209:6306;6824:83;;;:::i;:::-;;;;;;;;;;;;;2209:6306;;;;;;6926:38;;;2209:6306;6926:38;;2209:6306;;6926:38;2209:6306;6926:38;;;;;;;;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2209:6306:10;;;;;7062:10;2209:6306;;;;;;;;;;;;;;;;;;;;;7038:136;;2209:6306;;7038:136;2209:6306;;;;;;;;;6926:38;;;2209:6306;6926:38;;2209:6306;6926:38;;;;;;2209:6306;6926:38;;;:::i;:::-;;;2209:6306;;;;;6926:38;;;;;;-1:-1:-1;6926:38:10;;;2209:6306;;;;;;;;;6824:83;;;;;:::i;:::-;2209:6306;;6824:83;;;;6725:89;;;;;;2209:6306;6725:89;;:::i;:::-;2209:6306;6725:89;;;;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6095:143;2209:6306;;;;;;;;;6213:13;;2209:6306;;6194:10;;6213:13;:::i;:::-;6095:143;;;2209:6306;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;3541:48;2209:6306;3541:48;;2209:6306;3541:48;;2209:6306;3541:48;;2209:6306;;3557:14;2209:6306;3557:14;2209:6306;3557:14;2209:6306;3541:48;;;;;;;2209:6306;3541:48;;;2209:6306;;;;;;;;3622:39;;3650:10;2209:6306;3622:39;;2209:6306;;3622:39;2209:6306;3622:39;;;;;;;;;2209:6306;3622:39;;;2209:6306;;;;;3688:52;2209:6306;;;;;3688:15;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3688:52;2209:6306;;;;;;3650:10;3755:66;2209:6306;3650:10;3755:66;;2209:6306;;;;;;;;3622:39;;;;2209:6306;3622:39;2209:6306;3622:39;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;3541:48;;;;2209:6306;3541:48;2209:6306;3541:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;2290:39;2209:6306;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;5325:48;2209:6306;5325:48;;2209:6306;5325:48;;2209:6306;5325:48;;2209:6306;;5341:14;2209:6306;5341:14;2209:6306;5341:14;2209:6306;5325:48;;;;;;;2209:6306;5325:48;;;2209:6306;;;;;;;;5406:39;;5434:10;2209:6306;5406:39;;2209:6306;;5406:39;2209:6306;5406:39;;;;;;;;;2209:6306;5406:39;;;2209:6306;;;;;134:4:6;5480:17:10;;134:4:6;;2209:6306:10;;;5526:9;2209:6306;;;;;134:4:6;;;;;;;;;;;;;;2209:6306:10;;;;;5578:41;2209:6306;5434:10;5578:41;;2209:6306;134:4:6;;2209:6306:10;134:4:6;2209:6306:10;;134:4:6;5406:39:10;;;;2209:6306;5406:39;2209:6306;5406:39;;;;;;;:::i;:::-;;;;5325:48;;;;2209:6306;5325:48;2209:6306;5325:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;2520:81;2209:6306;;;;;;2520:81;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;4522:48;2209:6306;4522:48;;2209:6306;4522:48;;2209:6306;4522:48;;2209:6306;;4538:14;2209:6306;4538:14;2209:6306;4538:14;2209:6306;4522:48;;;;;;;2209:6306;4522:48;;;2209:6306;;;;;;;;4603:39;;4631:10;2209:6306;4603:39;;2209:6306;;4603:39;2209:6306;4603:39;;;;;;;;;2209:6306;4603:39;;;2209:6306;;;;;4669:83;2209:6306;;;;4669:17;2209:6306;;;;;4694:34;;;:::i;:::-;2209:6306;;;;;;;;;;;;;;;;;;;;;4669:83;2209:6306;;;;;;;;;;;;:::i;:::-;;;;;4767:84;2209:6306;4631:10;4767:84;;2209:6306;4603:39;;;;2209:6306;4603:39;2209:6306;4603:39;;;;;;;:::i;:::-;;;;4522:48;;;;2209:6306;4522:48;2209:6306;4522:48;;;;;;;:::i;:::-;;;;2209:6306;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;2209:6306:10;;;;:::o;:::-;;;:::o;8318:195::-;2209:6306;;;8451:54;;;2209:6306;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8451:54;;;;;;:::i;:::-;2209:6306;8441:65;;8318:195;:::o;395:128:8:-;2209:6306:10;;;;;;;;;;;;;;;;;;;;;;134:4:6;2209:6306:10;;395:128:8;:::o;2209:6306:10:-;;-1:-1:-1;2209:6306:10;;;;;-1:-1:-1;2209:6306:10;652:451:9;;761:17;;:21;2209:6306:10;;781:1:9;2209:6306:10;;;;;;;;867:54:9;;;;;;;;;2209:6306:10;867:54:9;;;2209:6306:10;;;;;;;;;;;867:54:9;;;;;;:::i;:::-;856:66;;;;;;:::i;:::-;2209:6306:10;;;;;;1000:22:9;;;:56;;;;;652:451;2209:6306:10;;;;;652:451:9:o;2209:6306:10:-;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10;1000:56:9;1026:30;;;867:54;1026:30;;;;;;;;:::i;:::-;1000:56;;;;2209:6306:10;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10;;;781:1:9;2209:6306:10;;781:1:9;2209:6306:10","linkReferences":{},"immutableReferences":{"1566":[{"start":1743,"length":32},{"start":2361,"length":32},{"start":4396,"length":32},{"start":4884,"length":32},{"start":5094,"length":32},{"start":5930,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"absoluteCap(address,bytes32)","signatureHash4":"0x08f804d8","signatureHash32":"0x08f804d8612d302d2a9a7bd1b2cde14d50a61f1134efd9db567ed143ee1d0161"},{"signature":"allocateFromIdle(address,address,(address,address,address,address,uint256),uint128,uint64)","signatureHash4":"0xdf31d688","signatureHash32":"0xdf31d688456027350e59ceaf04a015ffbc81288d466f64a0fbb08691a0ce3877"},{"signature":"canPullFromMarket(address,bytes32)","signatureHash4":"0x69f1e26b","signatureHash32":"0x69f1e26bf636dea2838f74d785f7e44230b0f77d52131c8296aa4c410d913924"},{"signature":"isActiveAdapter(address,address)","signatureHash4":"0x66faa839","signatureHash32":"0x66faa83979bb9fc39e4c9bfdefa75178cfebcd155a13781796ce9b21053bd767"},{"signature":"multicall(bytes[])","signatureHash4":"0xac9650d8","signatureHash32":"0xac9650d882acfa253cba1ed543b9ff47351da99c3bd00a89625e5cdb2099009c"},{"signature":"reallocate(address,address,(address,address,address,address,uint256),address,(address,address,address,address,uint256),uint128,uint64)","signatureHash4":"0x8fdaa1a7","signatureHash32":"0x8fdaa1a7cce988d98e9227ba763b51ca9473de3cbbac0ed0201f9bc988a4d79c"},{"signature":"setAbsoluteCap(address,address,(address,address,address,address,uint256),uint256)","signatureHash4":"0x9a8a6795","signatureHash32":"0x9a8a6795f3bf9a2ae7e2bc6cc128d99e623251cf770f3d996a823bf8f13972ff"},{"signature":"setCanPullFromIdle(address,bool)","signatureHash4":"0x9a8b5944","signatureHash32":"0x9a8b59442f75a86ec6413eede029c3776dda6eb7472e97f2c1277a44cc732669"},{"signature":"setCanPullFromMarket(address,address,(address,address,address,address,uint256),bool)","signatureHash4":"0x5e0deb54","signatureHash32":"0x5e0deb54a703b5e3d4df4502fc4af9e580d4b7d6ca6e29d5d7f43af7127aecec"},{"signature":"setIsActiveAdapter(address,address,bool)","signatureHash4":"0x8aeed1d1","signatureHash32":"0x8aeed1d109ddb1070d7ff178e8a6e3d7fd131cc44b07060ba1f29414d4c01bcd"},{"signature":"setPenalty(address,uint64)","signatureHash4":"0x77b0aab1","signatureHash32":"0x77b0aab148603c78c8182195d103cd77f68f97af5b7ddf17d30435bfd3898e7b"},{"signature":"vaultData(address)","signatureHash4":"0xd72ff79a","signatureHash32":"0xd72ff79a4da71469d0949dcf57eff72c464bf0702ea7bf3c167e5e83ee662a2e"},{"signature":"vaultV2Factory()","signatureHash4":"0x7953b569","signatureHash32":"0x7953b5693b02c33f15bc0e9cdf2eeedf57f3b85f2f65750a627193d7a9aa7d13"}],"event":[{"signature":"AllocateFromIdle(address,address,address,bytes32,uint128,uint256)","signatureHash4":"0x141dc311","signatureHash32":"0x141dc311848af2dd1094d09b33fbf388787803a6f8d59038c066adf920300cff"},{"signature":"Reallocate(address,address,address,bytes32,address,bytes32,uint128,uint256)","signatureHash4":"0x813a174e","signatureHash32":"0x813a174ef9435466c79f45c3051c14bab72e0c8f5d0f265105e33c3d6d5ddcf7"},{"signature":"SetAbsoluteCap(address,address,address,(address,address,address,address,uint256),uint256)","signatureHash4":"0x1a77abe8","signatureHash32":"0x1a77abe8031078d6f3fc79dbd2a5cfa48ae8dbb495fcf0b3124cf009bb6d91c3"},{"signature":"SetCanPullFromIdle(address,address,bool)","signatureHash4":"0x69f0f5f3","signatureHash32":"0x69f0f5f31610c9bb0b1c7325d8098a0c7d6093e0ea7fbf9920eb46f349bfe07c"},{"signature":"SetCanPullFromMarket(address,address,address,(address,address,address,address,uint256),bool)","signatureHash4":"0xacfd8002","signatureHash32":"0xacfd800238adbc79248c080c459b374b06feb519a69654529b318273686e1ab6"},{"signature":"SetIsActiveAdapter(address,address,address,bool)","signatureHash4":"0xcb0caee6","signatureHash32":"0xcb0caee6dfd90d41657a1c2834c4139aff2ad434ddb51eecd2ea298d3580953e"},{"signature":"SetPenalty(address,address,uint64)","signatureHash4":"0x87592866","signatureHash32":"0x87592866e19f1c7e3aba38aff71910bf6cde4d2aea6dd48bacc5d21b59f68b8c"}],"error":[{"signature":"AbsoluteCapExceeded()","signatureHash4":"0x4616e4af","signatureHash32":"0x4616e4af0a24a1d84272ba0457690313d4a5e61e5addd389a919c3685e256a5f"},{"signature":"CannotPullFromIdle()","signatureHash4":"0x79211beb","signatureHash32":"0x79211beb7ab134e212a05bdd8ba3be1fbe35ae2cdb625240a355faacd280e1e9"},{"signature":"CannotPullFromMarket()","signatureHash4":"0xff07b0d3","signatureHash32":"0xff07b0d30918b1929e6c14abaa367a052c42b3ffe5a628e8d2c4eb8772fb1e3f"},{"signature":"InactiveAdapter()","signatureHash4":"0x8d3a1180","signatureHash32":"0x8d3a118063773e753a8a066ceb7cfc87f8b5e5f6eaee11efa45315ed478c8b4c"},{"signature":"IncorrectPenalty()","signatureHash4":"0x7267792a","signatureHash32":"0x7267792a5c2fb2f6f615998a875b5f76f296358d02ef5e066a588cc3225c28be"},{"signature":"NoCode()","signatureHash4":"0xf046a714","signatureHash32":"0xf046a7143caa76e5a8eaa4f7b509b118bce2908ee7830dca6760ba2c6e4d3f00"},{"signature":"NotVaultV2()","signatureHash4":"0x1a9141e7","signatureHash32":"0x1a9141e74d43d703f5eb86f1ba01d628c2246c55aea8230ac54942a6190ae1b7"},{"signature":"PenaltyTooHigh()","signatureHash4":"0x516e7f38","signatureHash32":"0x516e7f3878f005f93f613eaf6032cfefddde305bb5fcfdcc15dbf10e81e2763a"},{"signature":"TransferFromReturnedFalse()","signatureHash4":"0x1eded19c","signatureHash32":"0x1eded19cd2129bae51a6830bdd6ed5f5099a63232d9c1f7e83bbbd18bc2a5d65"},{"signature":"TransferFromReverted()","signatureHash4":"0xe65b7a77","signatureHash32":"0xe65b7a7709254a5ab4d5cd236612987e04567891e2a6bdadadc6c54aafa0c9d0"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"ZeroAbsoluteCap()","signatureHash4":"0xbb1a23b9","signatureHash32":"0xbb1a23b9f11926d62b72c232a5c1697594133068abd6c393e455f3b190b82ec9"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"8453","address":"0xAED282B8aD9257BB1272e93aE63A32A53621e412"}